moving -Olocal-temps to -O4 until the issues are solved
[xonotic/gmqcc.git] / opts.c
1 /*
2  * Copyright (C) 2012, 2013
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_INVALID_PARAMETER_COUNT,   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     opts_set(opts.warn,  WARN_RESERVED_NAMES,            true);
58     opts_set(opts.warn,  WARN_UNINITIALIZED_CONSTANT,    true);
59     opts_set(opts.warn,  WARN_UNINITIALIZED_GLOBAL,      false);
60     opts_set(opts.warn,  WARN_DEPRECATED,                true);
61     opts_set(opts.warn,  WARN_PARENTHESIS,               true);
62     /* flags */
63     opts_set(opts.flags, ADJUST_VECTOR_FIELDS,           true);
64     opts_set(opts.flags, FTEPP,                          false);
65     opts_set(opts.flags, FTEPP_PREDEFS,                  false);
66     opts_set(opts.flags, CORRECT_TERNARY,                true);
67     opts_set(opts.flags, BAIL_ON_WERROR,                 true);
68     opts_set(opts.flags, ENHANCED_DIAGNOSTICS,           true);
69 }
70
71 void opts_init(const char *output, int standard, size_t arraysize) {
72     opts_setdefault();
73     
74     opts.output         = output;
75     opts.standard       = (opts_std_t)standard; /* C++ ... y u no like me? */
76     opts.max_array_size = arraysize;
77 }
78
79 static bool opts_setflag_all(const char *name, bool on, uint32_t *flags, const opts_flag_def *list, size_t listsize) {
80     size_t i;
81
82     for (i = 0; i < listsize; ++i) {
83         if (!strcmp(name, list[i].name)) {
84             longbit lb = list[i].bit;
85 #if 1
86             if (on)
87                 flags[lb.idx] |= (1<<(lb.bit));
88             else
89                 flags[lb.idx] &= ~(1<<(lb.bit));
90 #else
91             if (on)
92                 flags[0] |= (1<<lb);
93             else
94                 flags[0] &= ~(1<<(lb));
95 #endif
96             return true;
97         }
98     }
99     return false;
100 }
101 bool opts_setflag  (const char *name, bool on) {
102     return opts_setflag_all(name, on, opts.flags,        opts_flag_list, COUNT_FLAGS);
103 }
104 bool opts_setwarn  (const char *name, bool on) {
105     return opts_setflag_all(name, on, opts.warn,         opts_warn_list, COUNT_WARNINGS);
106 }
107 bool opts_setwerror(const char *name, bool on) {
108     return opts_setflag_all(name, on, opts.werror,       opts_warn_list, COUNT_WARNINGS);
109 }
110 bool opts_setoptim (const char *name, bool on) {
111     return opts_setflag_all(name, on, opts.optimization, opts_opt_list,  COUNT_OPTIMIZATIONS);
112 }
113
114 void opts_set(uint32_t *flags, size_t idx, bool on) {
115     longbit lb;
116     LONGBIT_SET(lb, idx);
117 #if 1
118     if (on)
119         flags[lb.idx] |= (1<<(lb.bit));
120     else
121         flags[lb.idx] &= ~(1<<(lb.bit));
122 #else
123     if (on)
124         flags[0] |= (1<<(lb));
125     else
126         flags[0] &= ~(1<<(lb));
127 #endif
128 }
129
130 void opts_setoptimlevel(unsigned int level) {
131     size_t i;
132     for (i = 0; i < COUNT_OPTIMIZATIONS; ++i)
133         opts_set(opts.optimization, i, level >= opts_opt_oflag[i]);
134 }
135
136 /*
137  * Standard configuration parser and subsystem.  Yes, optionally you may
138  * create ini files or cfg (the driver accepts both) for a project opposed
139  * to supplying just a progs.src (since you also may need to supply command
140  * line arguments or set the options of the compiler) [which cannot be done
141  * from a progs.src.
142  */
143 static char *opts_ini_rstrip(char *s) {
144     char *p = s + strlen(s);
145     while(p > s && isspace(*--p))
146         *p = '\0';
147     return s;
148 }
149
150 static char *opts_ini_lskip(const char *s) {
151     while (*s && isspace(*s))
152         s++;
153     return (char*)s;
154 }
155
156 static char *opts_ini_next(const char *s, char c) {
157     bool last = false;
158     while (*s && *s != c && !(last && *s == ';'))
159         last = !!isspace(*s), s++;
160
161     return (char*)s;
162 }
163
164 static size_t opts_ini_parse (
165     FILE   *filehandle,
166     char *(*loadhandle)(const char *, const char *, const char *),
167     char **errorhandle
168 ) {
169     size_t linesize;
170     size_t lineno             = 1;
171     size_t error              = 0;
172     char  *line               = NULL;
173     char   section_data[2048] = "";
174     char   oldname_data[2048] = "";
175
176     /* parsing and reading variables */
177     char *parse_beg;
178     char *parse_end;
179     char *read_name;
180     char *read_value;
181
182     while (file_getline(&line, &linesize, filehandle) != EOF) {
183         parse_beg = line;
184
185         /* handle BOM */
186         if (lineno == 1 && (
187                 (unsigned char)parse_beg[0] == 0xEF &&
188                 (unsigned char)parse_beg[1] == 0xBB &&
189                 (unsigned char)parse_beg[2] == 0xBF
190             )
191         ) {
192             parse_beg ++; /* 0xEF */
193             parse_beg ++; /* 0xBB */
194             parse_beg ++; /* 0xBF */
195         }
196
197         if (*(parse_beg = opts_ini_lskip(opts_ini_rstrip(parse_beg))) == ';' || *parse_beg == '#') {
198             /* ignore '#' is a perl extension */
199         } else if (*parse_beg == '[') {
200             /* section found */
201             if (*(parse_end = opts_ini_next(parse_beg + 1, ']')) == ']') {
202                 * parse_end = '\0'; /* terminate bro */
203                 strncpy(section_data, parse_beg + 1, sizeof(section_data));
204                 section_data[sizeof(section_data) - 1] = '\0';
205                 *oldname_data                          = '\0';
206             } else if (!error) {
207                 /* otherwise set error to the current line number */
208                 error = lineno;
209             }
210         } else if (*parse_beg && *parse_beg != ';') {
211             /* not a comment, must be a name value pair :) */
212             if (*(parse_end = opts_ini_next(parse_beg, '=')) != '=')
213                   parse_end = opts_ini_next(parse_beg, ':');
214
215             if (*parse_end == '=' || *parse_end == ':') {
216                 *parse_end = '\0'; /* terminate bro */
217                 read_name  = opts_ini_rstrip(parse_beg);
218                 read_value = opts_ini_lskip(parse_end + 1);
219                 if (*(parse_end = opts_ini_next(read_value, '\0')) == ';')
220                     * parse_end = '\0';
221                 opts_ini_rstrip(read_value);
222
223                 /* valid name value pair, lets call down to handler */
224                 strncpy(oldname_data, read_name, sizeof(oldname_data));
225                 oldname_data[sizeof(oldname_data) - 1] ='\0';
226
227                 if ((*errorhandle = loadhandle(section_data, read_name, read_value)) && !error)
228                     error = lineno;
229             } else if (!error) {
230                 /* otherwise set error to the current line number */
231                 error = lineno;
232             }
233         }
234         lineno++;
235     }
236     mem_d(line);
237     return error;
238 }
239
240 /*
241  * returns true/false for a char that contains ("true" or "false" or numeric 0/1)
242  */
243 static bool opts_ini_bool(const char *value) {
244     if (!strcmp(value, "true"))  return true;
245     if (!strcmp(value, "false")) return false;
246     return !!atoi(value);
247 }
248
249 static char *opts_ini_load(const char *section, const char *name, const char *value) {
250     char *error = NULL;
251     bool  found = false;
252
253     /*
254      * undef all of these because they may still be defined like in my
255      * case they where.
256      */  
257     #undef GMQCC_TYPE_FLAGS
258     #undef GMQCC_TYPE_OPTIMIZATIONS
259     #undef GMQCC_TYPE_WARNS
260
261     /* flags */
262     #define GMQCC_TYPE_FLAGS
263     #define GMQCC_DEFINE_FLAG(X)                                       \
264     if (!strcmp(section, "flags") && !strcmp(name, #X)) {              \
265         opts_set(opts.flags, X, opts_ini_bool(value));                 \
266         found = true;                                                  \
267     }
268     #include "opts.def"
269
270     /* warnings */
271     #define GMQCC_TYPE_WARNS
272     #define GMQCC_DEFINE_FLAG(X)                                       \
273     if (!strcmp(section, "warnings") && !strcmp(name, #X)) {           \
274         opts_set(opts.warn, WARN_##X, opts_ini_bool(value));           \
275         found = true;                                                  \
276     }
277     #include "opts.def"
278
279     /* optimizations */
280     #define GMQCC_TYPE_OPTIMIZATIONS
281     #define GMQCC_DEFINE_FLAG(X,Y)                                     \
282     if (!strcmp(section, "optimizations") && !strcmp(name, #X)) {      \
283         opts_set(opts.optimization, OPTIM_##X, opts_ini_bool(value));  \
284         found = true;                                                  \
285     }
286     #include "opts.def"
287
288     /* nothing was found ever! */
289     if (!found) {
290         if (strcmp(section, "flags")         &&
291             strcmp(section, "warnings")      &&
292             strcmp(section, "optimizations"))
293         {
294             vec_upload(error, "invalid section `", 17);
295             vec_upload(error, section, strlen(section));
296             vec_push  (error, '`');
297             vec_push  (error, '\0');
298         } else {
299             vec_upload(error, "invalid variable `", 18);
300             vec_upload(error, name, strlen(name));
301             vec_push  (error, '`');
302             vec_upload(error, " in section: `", 14);
303             vec_upload(error, section, strlen(section));
304             vec_push  (error, '`');
305             vec_push  (error, '\0');
306         }
307     }
308     return error;
309 }
310
311 /*
312  * Actual loading subsystem, this finds the ini or cfg file, and properly
313  * loads it and executes it to set compiler options.
314  */
315 void opts_ini_init(const char *file) {
316     /*
317      * Possible matches are:
318      *  gmqcc.ini
319      *  gmqcc.cfg
320      */
321     char       *error;
322     size_t     line;
323     FILE       *ini;
324
325     
326     if (!file) {
327         /* try ini */
328         if (!(ini = file_open((file = "gmqcc.ini"), "r")))
329             /* try cfg */
330             if (!(ini = file_open((file = "gmqcc.cfg"), "r")))
331                 return;
332     } else if (!(ini = file_open(file, "r")))
333         return;
334
335     con_out("found ini file `%s`\n", file);
336
337     if ((line = opts_ini_parse(ini, &opts_ini_load, &error)) != 0) {
338         /* there was a parse error with the ini file */
339         con_printmsg(LVL_ERROR, file, line, "error", error);
340         vec_free(error);
341     }
342
343     file_close(ini);
344 }