-fbail-on-werror option
[xonotic/gmqcc.git] / opts.c
1 /*
2  * Copyright (C) 2012
3  *     Wolfgang Bumiller
4  *     Dale Weiler 
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy of
7  * this software and associated documentation files (the "Software"), to deal in
8  * the Software without restriction, including without limitation the rights to
9  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
10  * of the Software, and to permit persons to whom the Software is furnished to do
11  * so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24 #include "gmqcc.h"
25 unsigned int opts_optimizationcount[COUNT_OPTIMIZATIONS];
26 opts_cmd_t   opts; /* command lien options */
27
28 static void opts_setdefault() {
29     memset(&opts, 0, sizeof(opts_cmd_t));
30     
31     /* warnings */
32     opts_set(opts.warn,  WARN_UNUSED_VARIABLE,           true);
33     opts_set(opts.warn,  WARN_USED_UNINITIALIZED,        true);
34     opts_set(opts.warn,  WARN_UNKNOWN_CONTROL_SEQUENCE,  true);
35     opts_set(opts.warn,  WARN_EXTENSIONS,                true);
36     opts_set(opts.warn,  WARN_FIELD_REDECLARED,          true);
37     opts_set(opts.warn,  WARN_MISSING_RETURN_VALUES,     true);
38     opts_set(opts.warn,  WARN_TOO_FEW_PARAMETERS,        true);
39     opts_set(opts.warn,  WARN_LOCAL_SHADOWS,             false);
40     opts_set(opts.warn,  WARN_LOCAL_CONSTANTS,           true);
41     opts_set(opts.warn,  WARN_VOID_VARIABLES,            true);
42     opts_set(opts.warn,  WARN_IMPLICIT_FUNCTION_POINTER, true);
43     opts_set(opts.warn,  WARN_VARIADIC_FUNCTION,         true);
44     opts_set(opts.warn,  WARN_FRAME_MACROS,              true);
45     opts_set(opts.warn,  WARN_EFFECTLESS_STATEMENT,      true);
46     opts_set(opts.warn,  WARN_END_SYS_FIELDS,            true);
47     opts_set(opts.warn,  WARN_ASSIGN_FUNCTION_TYPES,     true);
48     opts_set(opts.warn,  WARN_PREPROCESSOR,              true);
49     opts_set(opts.warn,  WARN_MULTIFILE_IF,              true);
50     opts_set(opts.warn,  WARN_DOUBLE_DECLARATION,        true);
51     opts_set(opts.warn,  WARN_CONST_VAR,                 true);
52     opts_set(opts.warn,  WARN_MULTIBYTE_CHARACTER,       true);
53     opts_set(opts.warn,  WARN_UNKNOWN_PRAGMAS,           true);
54     opts_set(opts.warn,  WARN_UNREACHABLE_CODE,          true);
55     opts_set(opts.warn,  WARN_CPP,                       true);
56     opts_set(opts.warn,  WARN_UNKNOWN_ATTRIBUTE,         true);
57     /* flags */
58     opts_set(opts.flags, ADJUST_VECTOR_FIELDS,           true);
59     opts_set(opts.flags, FTEPP,                          false);
60     opts_set(opts.flags, FTEPP_PREDEFS,                  false);
61     opts_set(opts.flags, CORRECT_TERNARY,                true);
62     opts_set(opts.flags, BAIL_ON_WERROR,                 true);
63 }
64
65 void opts_init(const char *output, int standard, size_t arraysize) {
66     opts_setdefault();
67     
68     opts.output         = output;
69     opts.standard       = (opts_std_t)standard; /* C++ ... y u no like me? */
70     opts.max_array_size = arraysize;
71 }
72
73 static bool opts_setflag_all(const char *name, bool on, uint32_t *flags, const opts_flag_def *list, size_t listsize) {
74     size_t i;
75
76     for (i = 0; i < listsize; ++i) {
77         if (!strcmp(name, list[i].name)) {
78             longbit lb = list[i].bit;
79 #if 1
80             if (on)
81                 flags[lb.idx] |= (1<<(lb.bit));
82             else
83                 flags[lb.idx] &= ~(1<<(lb.bit));
84 #else
85             if (on)
86                 flags[0] |= (1<<lb);
87             else
88                 flags[0] &= ~(1<<(lb));
89 #endif
90             return true;
91         }
92     }
93     return false;
94 }
95 bool opts_setflag  (const char *name, bool on) {
96     return opts_setflag_all(name, on, opts.flags,        opts_flag_list, COUNT_FLAGS);
97 }
98 bool opts_setwarn  (const char *name, bool on) {
99     return opts_setflag_all(name, on, opts.warn,         opts_warn_list, COUNT_WARNINGS);
100 }
101 bool opts_setwerror(const char *name, bool on) {
102     return opts_setflag_all(name, on, opts.werror,       opts_warn_list, COUNT_WARNINGS);
103 }
104 bool opts_setoptim (const char *name, bool on) {
105     return opts_setflag_all(name, on, opts.optimization, opts_opt_list,  COUNT_OPTIMIZATIONS);
106 }
107
108 void opts_set(uint32_t *flags, size_t idx, bool on) {
109     longbit lb;
110     LONGBIT_SET(lb, idx);
111 #if 1
112     if (on)
113         flags[lb.idx] |= (1<<(lb.bit));
114     else
115         flags[lb.idx] &= ~(1<<(lb.bit));
116 #else
117     if (on)
118         flags[0] |= (1<<(lb));
119     else
120         flags[0] &= ~(1<<(lb));
121 #endif
122 }
123
124 void opts_setoptimlevel(unsigned int level) {
125     size_t i;
126     for (i = 0; i < COUNT_OPTIMIZATIONS; ++i)
127         opts_set(opts.optimization, i, level >= opts_opt_oflag[i]);
128 }
129
130 /*
131  * Standard configuration parser and subsystem.  Yes, optionally you may
132  * create ini files or cfg (the driver accepts both) for a project opposed
133  * to supplying just a progs.src (since you also may need to supply command
134  * line arguments or set the options of the compiler) [which cannot be done
135  * from a progs.src.
136  */
137 static char *opts_ini_rstrip(char *s) {
138     char *p = s + strlen(s);
139     while(p > s && isspace(*--p))
140         *p = '\0';
141     return s;
142 }
143
144 static char *opts_ini_lskip(const char *s) {
145     while (*s && isspace(*s))
146         s++;
147     return (char*)s;
148 }
149
150 static char *opts_ini_next(const char *s, char c) {
151     bool last = false;
152     while (*s && *s != c && !(last && *s == ';'))
153         last = !!isspace(*s), s++;
154
155     return (char*)s;
156 }
157
158 static size_t opts_ini_parse (
159     FILE   *filehandle,
160     char *(*loadhandle)(const char *, const char *, const char *),
161     char **errorhandle
162 ) {
163     size_t linesize;
164     size_t lineno             = 1;
165     size_t error              = 0;
166     char  *line               = NULL;
167     char   section_data[2048] = "";
168     char   oldname_data[2048] = "";
169
170     /* parsing and reading variables */
171     char *parse_beg;
172     char *parse_end;
173     char *read_name;
174     char *read_value;
175
176     while (file_getline(&line, &linesize, filehandle) != EOF) {
177         parse_beg = line;
178
179         /* handle BOM */
180         if (lineno == 1 && (
181                 (unsigned char)parse_beg[0] == 0xEF &&
182                 (unsigned char)parse_beg[1] == 0xBB &&
183                 (unsigned char)parse_beg[2] == 0xBF
184             )
185         ) {
186             parse_beg ++; /* 0xEF */
187             parse_beg ++; /* 0xBB */
188             parse_beg ++; /* 0xBF */
189         }
190
191         if (*(parse_beg = opts_ini_lskip(opts_ini_rstrip(parse_beg))) == ';' || *parse_beg == '#') {
192             /* ignore '#' is a perl extension */
193         } else if (*parse_beg == '[') {
194             /* section found */
195             if (*(parse_end = opts_ini_next(parse_beg + 1, ']')) == ']') {
196                 * parse_end = '\0'; /* terminate bro */
197                 strncpy(section_data, parse_beg + 1, sizeof(section_data));
198                 section_data[sizeof(section_data) - 1] = '\0';
199                 *oldname_data                          = '\0';
200             } else if (!error) {
201                 /* otherwise set error to the current line number */
202                 error = lineno;
203             }
204         } else if (*parse_beg && *parse_beg != ';') {
205             /* not a comment, must be a name value pair :) */
206             if (*(parse_end = opts_ini_next(parse_beg, '=')) != '=')
207                   parse_end = opts_ini_next(parse_beg, ':');
208
209             if (*parse_end == '=' || *parse_end == ':') {
210                 *parse_end = '\0'; /* terminate bro */
211                 read_name  = opts_ini_rstrip(parse_beg);
212                 read_value = opts_ini_lskip(parse_end + 1);
213                 if (*(parse_end = opts_ini_next(read_value, '\0')) == ';')
214                     * parse_end = '\0';
215                 opts_ini_rstrip(read_value);
216
217                 /* valid name value pair, lets call down to handler */
218                 strncpy(oldname_data, read_name, sizeof(oldname_data));
219                 oldname_data[sizeof(oldname_data) - 1] ='\0';
220
221                 if ((*errorhandle = loadhandle(section_data, read_name, read_value)) && !error)
222                     error = lineno;
223             } else if (!error) {
224                 /* otherwise set error to the current line number */
225                 error = lineno;
226             }
227         }
228         lineno++;
229     }
230     mem_d(line);
231     return error;
232 }
233
234 /*
235  * returns true/false for a char that contains ("true" or "false" or numeric 0/1)
236  */
237 static bool opts_ini_bool(const char *value) {
238     if (!strcmp(value, "true"))  return true;
239     if (!strcmp(value, "false")) return false;
240     return !!atoi(value);
241 }
242
243 static char *opts_ini_load(const char *section, const char *name, const char *value) {
244     char *error = NULL;
245     bool  found = false;
246
247     /*
248      * undef all of these because they may still be defined like in my
249      * case they where.
250      */  
251     #undef GMQCC_TYPE_FLAGS
252     #undef GMQCC_TYPE_OPTIMIZATIONS
253     #undef GMQCC_TYPE_WARNS
254
255     /* flags */
256     #define GMQCC_TYPE_FLAGS
257     #define GMQCC_DEFINE_FLAG(X)                                       \
258     if (!strcmp(section, "flags") && !strcmp(name, #X)) {              \
259         opts_set(opts.flags, X, opts_ini_bool(value));                 \
260         found = true;                                                  \
261     }
262     #include "opts.def"
263
264     /* warnings */
265     #define GMQCC_TYPE_WARNS
266     #define GMQCC_DEFINE_FLAG(X)                                       \
267     if (!strcmp(section, "warnings") && !strcmp(name, #X)) {           \
268         opts_set(opts.warn, WARN_##X, opts_ini_bool(value));           \
269         found = true;                                                  \
270     }
271     #include "opts.def"
272
273     /* optimizations */
274     #define GMQCC_TYPE_OPTIMIZATIONS
275     #define GMQCC_DEFINE_FLAG(X,Y)                                     \
276     if (!strcmp(section, "optimizations") && !strcmp(name, #X)) {      \
277         opts_set(opts.optimization, OPTIM_##X, opts_ini_bool(value));  \
278         found = true;                                                  \
279     }
280     #include "opts.def"
281
282     /* nothing was found ever! */
283     if (!found) {
284         if (strcmp(section, "flags")         &&
285             strcmp(section, "warnings")      &&
286             strcmp(section, "optimizations"))
287         {
288             vec_upload(error, "invalid section `", 17);
289             vec_upload(error, section, strlen(section));
290             vec_push  (error, '`');
291             vec_push  (error, '\0');
292         } else {
293             vec_upload(error, "invalid variable `", 18);
294             vec_upload(error, name, strlen(name));
295             vec_push  (error, '`');
296             vec_upload(error, " in section: `", 14);
297             vec_upload(error, section, strlen(section));
298             vec_push  (error, '`');
299             vec_push  (error, '\0');
300         }
301     }
302     return error;
303 }
304
305 /*
306  * Actual loading subsystem, this finds the ini or cfg file, and properly
307  * loads it and executes it to set compiler options.
308  */
309 void opts_ini_init(const char *file) {
310     /*
311      * Possible matches are:
312      *  gmqcc.ini
313      *  gmqcc.cfg
314      */
315     char       *error;
316     size_t     line;
317     FILE       *ini;
318
319     
320     if (!file) {
321         /* try ini */
322         if (!(ini = file_open((file = "gmqcc.ini"), "r")))
323             /* try cfg */
324             if (!(ini = file_open((file = "gmqcc.cfg"), "r")))
325                 return;
326     } else if (!(ini = file_open(file, "r")))
327         return;
328
329     con_out("found ini file `%s`\n", file);
330
331     if ((line = opts_ini_parse(ini, &opts_ini_load, &error)) != 0) {
332         /* there was a parse error with the ini file */
333         con_printmsg(LVL_ERROR, file, line, "error", error);
334         vec_free(error);
335     }
336
337     file_close(ini);
338 }