1 /*
2 * Copyright (C) 2010 Dan Carpenter.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
16 */
17
18 /*
19 * This file is only for very generic stuff, that is reusable
20 * between projects. If you need something special create a
21 * check_your_project.c.
22 *
23 */
24
25 #include "smatch.h"
26 #include "smatch_extra.h"
27 #include "smatch_function_hashtable.h"
28
29 static DEFINE_HASHTABLE_INSERT(insert_func, char, int);
30 static DEFINE_HASHTABLE_SEARCH(search_func, char, int);
31 static struct hashtable *skipped_funcs;
32 static struct hashtable *silenced_funcs;
33 static struct hashtable *no_inline_funcs;
34
35 int is_skipped_function(void)
36 {
37 char *func;
38
39 func = get_function();
40 if (!func)
41 return 0;
42 if (search_func(skipped_funcs, func))
43 return 1;
44 return 0;
45 }
46
47 /*
48 * A silenced function will still be processed and potentially appear in info
49 * output, but not regular checks.
50 */
51 int is_silenced_function(void)
52 {
53 char *func;
54
55 if (is_skipped_function())
56 return 1;
57
58 func = get_function();
59 if (!func)
60 return 0;
61 if (search_func(silenced_funcs, func))
62 return 1;
63 return 0;
64 }
65
66 int is_no_inline_function(const char *function)
67 {
68 if (search_func(no_inline_funcs, (char *)function))
69 return 1;
70 return 0;
71 }
72
73 static void register_no_return_funcs(void)
74 {
75 struct token *token;
76 const char *func;
77 char name[256];
78
79 snprintf(name, 256, "%s.no_return_funcs", option_project_str);
80
81 token = get_tokens_file(name);
82 if (!token)
83 return;
84 if (token_type(token) != TOKEN_STREAMBEGIN)
85 return;
86 token = token->next;
87 while (token_type(token) != TOKEN_STREAMEND) {
88 if (token_type(token) != TOKEN_IDENT)
89 return;
90 func = show_ident(token->ident);
91 add_function_hook(func, &__match_nullify_path_hook, NULL);
92 token = token->next;
93 }
94 clear_token_alloc();
95 }
96
97 static void register_ignored_macros(void)
98 {
99 struct token *token;
100 char *macro;
101 char name[256];
102
103 if (option_project == PROJ_NONE)
104 strcpy(name, "ignored_macros");
105 else
106 snprintf(name, 256, "%s.ignored_macros", option_project_str);
107
108 token = get_tokens_file(name);
109 if (!token)
110 return;
111 if (token_type(token) != TOKEN_STREAMBEGIN)
112 return;
113 token = token->next;
114 while (token_type(token) != TOKEN_STREAMEND) {
115 if (token_type(token) != TOKEN_IDENT)
116 return;
117 macro = alloc_string(show_ident(token->ident));
118 add_ptr_list(&__ignored_macros, macro);
119 token = token->next;
120 }
121 clear_token_alloc();
122 }
123
124 static void register_skipped_functions(void)
125 {
126 struct token *token;
127 char *func;
128 char name[256];
129
130 skipped_funcs = create_function_hashtable(500);
131
132 if (option_project == PROJ_NONE)
133 return;
134
135 snprintf(name, 256, "%s.skipped_functions", option_project_str);
136
137 token = get_tokens_file(name);
138 if (!token)
139 return;
140 if (token_type(token) != TOKEN_STREAMBEGIN)
141 return;
142 token = token->next;
143 while (token_type(token) != TOKEN_STREAMEND) {
144 if (token_type(token) != TOKEN_IDENT)
145 return;
146 func = alloc_string(show_ident(token->ident));
147 insert_func(skipped_funcs, func, INT_PTR(1));
148 token = token->next;
149 }
150 clear_token_alloc();
151 }
152
153 static void register_silenced_functions(void)
154 {
155 struct token *token;
156 char *func;
157 char name[256];
158
159 silenced_funcs = create_function_hashtable(500);
160
161 if (option_project == PROJ_NONE)
162 return;
163
164 snprintf(name, 256, "%s.silenced_functions", option_project_str);
165
166 token = get_tokens_file(name);
167 if (!token)
168 return;
169 if (token_type(token) != TOKEN_STREAMBEGIN)
170 return;
171 token = token->next;
172 while (token_type(token) != TOKEN_STREAMEND) {
173 if (token_type(token) != TOKEN_IDENT)
174 return;
175 func = alloc_string(show_ident(token->ident));
176 insert_func(silenced_funcs, func, INT_PTR(1));
177 token = token->next;
178 }
179 clear_token_alloc();
180 }
181
182 static void register_no_inline_functions(void)
183 {
184 struct token *token;
185 char *func;
186 char name[256];
187
188 no_inline_funcs = create_function_hashtable(500);
189
190 if (option_project == PROJ_NONE)
191 return;
192
193 snprintf(name, 256, "%s.no_inline_functions", option_project_str);
194
195 token = get_tokens_file(name);
196 if (!token)
197 return;
198 if (token_type(token) != TOKEN_STREAMBEGIN)
199 return;
200 token = token->next;
201 while (token_type(token) != TOKEN_STREAMEND) {
202 if (token_type(token) != TOKEN_IDENT)
203 return;
204 func = alloc_string(show_ident(token->ident));
205 insert_func(no_inline_funcs, func, INT_PTR(1));
206 token = token->next;
207 }
208 clear_token_alloc();
209 }
210
211 void register_project(int id)
212 {
213 register_no_return_funcs();
214 register_ignored_macros();
215 register_skipped_functions();
216 register_silenced_functions();
217 register_no_inline_functions();
218 }