Use the _t consistency naming scheme. Also various cleanups.
[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 <string.h>
25 #include <stdlib.h>
26
27 #include "gmqcc.h"
28
29 const unsigned int opts_opt_oflag[COUNT_OPTIMIZATIONS+1] = {
30 # define GMQCC_TYPE_OPTIMIZATIONS
31 # define GMQCC_DEFINE_FLAG(NAME, MIN_O) MIN_O,
32 #  include "opts.def"
33     0
34 };
35
36 const opts_flag_def_t opts_opt_list[COUNT_OPTIMIZATIONS+1] = {
37 # define GMQCC_TYPE_OPTIMIZATIONS
38 # define GMQCC_DEFINE_FLAG(NAME, MIN_O) { #NAME, LONGBIT(OPTIM_##NAME) },
39 #  include "opts.def"
40     { NULL, LONGBIT(0) }
41 };
42
43 const opts_flag_def_t opts_warn_list[COUNT_WARNINGS+1] = {
44 # define GMQCC_TYPE_WARNS
45 # define GMQCC_DEFINE_FLAG(X) { #X, LONGBIT(WARN_##X) },
46 #  include "opts.def"
47     { NULL, LONGBIT(0) }
48 };
49
50 const opts_flag_def_t opts_flag_list[COUNT_FLAGS+1] = {
51 # define GMQCC_TYPE_FLAGS
52 # define GMQCC_DEFINE_FLAG(X) { #X, LONGBIT(X) },
53 #  include "opts.def"
54     { NULL, LONGBIT(0) }
55 };
56
57 unsigned int opts_optimizationcount[COUNT_OPTIMIZATIONS];
58 opts_cmd_t   opts; /* command lien options */
59
60 static void opts_setdefault(void) {
61     memset(&opts, 0, sizeof(opts_cmd_t));
62     OPTS_OPTION_BOOL(OPTION_CORRECTION) = true;
63
64     /* warnings */
65     opts_set(opts.warn,  WARN_UNUSED_VARIABLE,           true);
66     opts_set(opts.warn,  WARN_USED_UNINITIALIZED,        true);
67     opts_set(opts.warn,  WARN_UNKNOWN_CONTROL_SEQUENCE,  true);
68     opts_set(opts.warn,  WARN_EXTENSIONS,                true);
69     opts_set(opts.warn,  WARN_FIELD_REDECLARED,          true);
70     opts_set(opts.warn,  WARN_MISSING_RETURN_VALUES,     true);
71     opts_set(opts.warn,  WARN_INVALID_PARAMETER_COUNT,   true);
72     opts_set(opts.warn,  WARN_LOCAL_CONSTANTS,           true);
73     opts_set(opts.warn,  WARN_VOID_VARIABLES,            true);
74     opts_set(opts.warn,  WARN_IMPLICIT_FUNCTION_POINTER, true);
75     opts_set(opts.warn,  WARN_VARIADIC_FUNCTION,         true);
76     opts_set(opts.warn,  WARN_FRAME_MACROS,              true);
77     opts_set(opts.warn,  WARN_EFFECTLESS_STATEMENT,      true);
78     opts_set(opts.warn,  WARN_END_SYS_FIELDS,            true);
79     opts_set(opts.warn,  WARN_ASSIGN_FUNCTION_TYPES,     true);
80     opts_set(opts.warn,  WARN_CPP,                       true);
81     opts_set(opts.warn,  WARN_MULTIFILE_IF,              true);
82     opts_set(opts.warn,  WARN_DOUBLE_DECLARATION,        true);
83     opts_set(opts.warn,  WARN_CONST_VAR,                 true);
84     opts_set(opts.warn,  WARN_MULTIBYTE_CHARACTER,       true);
85     opts_set(opts.warn,  WARN_UNKNOWN_PRAGMAS,           true);
86     opts_set(opts.warn,  WARN_UNREACHABLE_CODE,          true);
87     opts_set(opts.warn,  WARN_UNKNOWN_ATTRIBUTE,         true);
88     opts_set(opts.warn,  WARN_RESERVED_NAMES,            true);
89     opts_set(opts.warn,  WARN_UNINITIALIZED_CONSTANT,    true);
90     opts_set(opts.warn,  WARN_DEPRECATED,                true);
91     opts_set(opts.warn,  WARN_PARENTHESIS,               true);
92
93     /* flags */
94     opts_set(opts.flags, ADJUST_VECTOR_FIELDS,           true);
95     opts_set(opts.flags, CORRECT_TERNARY,                true);
96     opts_set(opts.flags, BAIL_ON_WERROR,                 true);
97     opts_set(opts.flags, LEGACY_VECTOR_MATHS,            true);
98     opts_set(opts.flags, DARKPLACES_STRING_TABLE_BUG,    true);
99
100 }
101
102 void opts_backup_non_Wall() {
103     size_t i;
104     for (i = 0; i <= WARN_DEBUG; ++i)
105         opts_set(opts.warn_backup, i, OPTS_WARN(i));
106 }
107
108 void opts_restore_non_Wall() {
109     size_t i;
110     for (i = 0; i <= WARN_DEBUG; ++i)
111         opts_set(opts.warn, i, OPTS_GENERIC(opts.warn_backup, i));
112 }
113
114 void opts_backup_non_Werror_all() {
115     size_t i;
116     for (i = 0; i <= WARN_DEBUG; ++i)
117         opts_set(opts.werror_backup, i, OPTS_WERROR(i));
118 }
119
120 void opts_restore_non_Werror_all() {
121     size_t i;
122     for (i = 0; i <= WARN_DEBUG; ++i)
123         opts_set(opts.werror, i, OPTS_GENERIC(opts.werror_backup, i));
124 }
125
126 void opts_init(const char *output, int standard, size_t arraysize) {
127     opts_setdefault();
128
129     OPTS_OPTION_STR(OPTION_OUTPUT)         = (char*)output;
130     OPTS_OPTION_U32(OPTION_STANDARD)       = standard;
131     OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE) = arraysize;
132     OPTS_OPTION_U16(OPTION_MEMDUMPCOLS)    = 16;
133 }
134
135 static bool opts_setflag_all(const char *name, bool on, uint32_t *flags, const opts_flag_def_t *list, size_t listsize) {
136     size_t i;
137
138     for (i = 0; i < listsize; ++i) {
139         if (!strcmp(name, list[i].name)) {
140             longbit lb = list[i].bit;
141
142             if (on)
143                 flags[lb.idx] |= (1<<(lb.bit));
144             else
145                 flags[lb.idx] &= ~(1<<(lb.bit));
146
147             return true;
148         }
149     }
150     return false;
151 }
152 bool opts_setflag  (const char *name, bool on) {
153     return opts_setflag_all(name, on, opts.flags,        opts_flag_list, COUNT_FLAGS);
154 }
155 bool opts_setwarn  (const char *name, bool on) {
156     return opts_setflag_all(name, on, opts.warn,         opts_warn_list, COUNT_WARNINGS);
157 }
158 bool opts_setwerror(const char *name, bool on) {
159     return opts_setflag_all(name, on, opts.werror,       opts_warn_list, COUNT_WARNINGS);
160 }
161 bool opts_setoptim (const char *name, bool on) {
162     return opts_setflag_all(name, on, opts.optimization, opts_opt_list,  COUNT_OPTIMIZATIONS);
163 }
164
165 void opts_set(uint32_t *flags, size_t idx, bool on) {
166     longbit lb;
167     LONGBIT_SET(lb, idx);
168
169     if (on)
170         flags[lb.idx] |= (1<<(lb.bit));
171     else
172         flags[lb.idx] &= ~(1<<(lb.bit));
173 }
174
175 void opts_setoptimlevel(unsigned int level) {
176     size_t i;
177     for (i = 0; i < COUNT_OPTIMIZATIONS; ++i)
178         opts_set(opts.optimization, i, level >= opts_opt_oflag[i]);
179
180     if (!level)
181         opts.optimizeoff = true;
182 }
183
184 /*
185  * Standard configuration parser and subsystem.  Yes, optionally you may
186  * create ini files or cfg (the driver accepts both) for a project opposed
187  * to supplying just a progs.src (since you also may need to supply command
188  * line arguments or set the options of the compiler) [which cannot be done
189  * from a progs.src.
190  */
191 static char *opts_ini_rstrip(char *s) {
192     char *p = s + strlen(s);
193     while(p > s && util_isspace(*--p))
194         *p = '\0';
195     return s;
196 }
197
198 static char *opts_ini_lskip(const char *s) {
199     while (*s && util_isspace(*s))
200         s++;
201     return (char*)s;
202 }
203
204 static char *opts_ini_next(const char *s, char c) {
205     bool last = false;
206     while (*s && *s != c && !(last && *s == ';'))
207         last = !!util_isspace(*s), s++;
208
209     return (char*)s;
210 }
211
212 static size_t opts_ini_parse (
213     FILE   *filehandle,
214     char *(*loadhandle)(const char *, const char *, const char *),
215     char **errorhandle
216 ) {
217     size_t linesize;
218     size_t lineno             = 1;
219     size_t error              = 0;
220     char  *line               = NULL;
221     char   section_data[2048] = "";
222     char   oldname_data[2048] = "";
223
224     /* parsing and reading variables */
225     char *parse_beg;
226     char *parse_end;
227     char *read_name;
228     char *read_value;
229
230     while (fs_file_getline(&line, &linesize, filehandle) != EOF) {
231         parse_beg = line;
232
233         /* handle BOM */
234         if (lineno == 1 && (
235                 (unsigned char)parse_beg[0] == 0xEF &&
236                 (unsigned char)parse_beg[1] == 0xBB &&
237                 (unsigned char)parse_beg[2] == 0xBF
238             )
239         ) {
240             parse_beg ++; /* 0xEF */
241             parse_beg ++; /* 0xBB */
242             parse_beg ++; /* 0xBF */
243         }
244
245         if (*(parse_beg = opts_ini_lskip(opts_ini_rstrip(parse_beg))) == ';' || *parse_beg == '#') {
246             /* ignore '#' is a perl extension */
247         } else if (*parse_beg == '[') {
248             /* section found */
249             if (*(parse_end = opts_ini_next(parse_beg + 1, ']')) == ']') {
250                 * parse_end = '\0'; /* terminate bro */
251                 util_strncpy(section_data, parse_beg + 1, sizeof(section_data));
252                 section_data[sizeof(section_data) - 1] = '\0';
253                 *oldname_data                          = '\0';
254             } else if (!error) {
255                 /* otherwise set error to the current line number */
256                 error = lineno;
257             }
258         } else if (*parse_beg && *parse_beg != ';') {
259             /* not a comment, must be a name value pair :) */
260             if (*(parse_end = opts_ini_next(parse_beg, '=')) != '=')
261                   parse_end = opts_ini_next(parse_beg, ':');
262
263             if (*parse_end == '=' || *parse_end == ':') {
264                 *parse_end = '\0'; /* terminate bro */
265                 read_name  = opts_ini_rstrip(parse_beg);
266                 read_value = opts_ini_lskip(parse_end + 1);
267                 if (*(parse_end = opts_ini_next(read_value, '\0')) == ';')
268                     * parse_end = '\0';
269                 opts_ini_rstrip(read_value);
270
271                 /* valid name value pair, lets call down to handler */
272                 util_strncpy(oldname_data, read_name, sizeof(oldname_data));
273                 oldname_data[sizeof(oldname_data) - 1] ='\0';
274
275                 if ((*errorhandle = loadhandle(section_data, read_name, read_value)) && !error)
276                     error = lineno;
277             } else if (!error) {
278                 /* otherwise set error to the current line number */
279                 error = lineno;
280             }
281         }
282         lineno++;
283     }
284     mem_d(line);
285     return error;
286 }
287
288 /*
289  * returns true/false for a char that contains ("true" or "false" or numeric 0/1)
290  */
291 static bool opts_ini_bool(const char *value) {
292     if (!strcmp(value, "true"))  return true;
293     if (!strcmp(value, "false")) return false;
294     return !!strtol(value, NULL, 10);
295 }
296
297 static char *opts_ini_load(const char *section, const char *name, const char *value) {
298     char *error = NULL;
299     bool  found = false;
300
301     /*
302      * undef all of these because they may still be defined like in my
303      * case they where.
304      */
305     #undef GMQCC_TYPE_FLAGS
306     #undef GMQCC_TYPE_OPTIMIZATIONS
307     #undef GMQCC_TYPE_WARNS
308
309     /* flags */
310     #define GMQCC_TYPE_FLAGS
311     #define GMQCC_DEFINE_FLAG(X)                                       \
312     if (!strcmp(section, "flags") && !strcmp(name, #X)) {              \
313         opts_set(opts.flags, X, opts_ini_bool(value));                 \
314         found = true;                                                  \
315     }
316     #include "opts.def"
317
318     /* warnings */
319     #define GMQCC_TYPE_WARNS
320     #define GMQCC_DEFINE_FLAG(X)                                       \
321     if (!strcmp(section, "warnings") && !strcmp(name, #X)) {           \
322         opts_set(opts.warn, WARN_##X, opts_ini_bool(value));           \
323         found = true;                                                  \
324     }
325     #include "opts.def"
326
327     /* Werror-individuals */
328     #define GMQCC_TYPE_WARNS
329     #define GMQCC_DEFINE_FLAG(X)                                       \
330     if (!strcmp(section, "errors") && !strcmp(name, #X)) {             \
331         opts_set(opts.werror, WARN_##X, opts_ini_bool(value));         \
332         found = true;                                                  \
333     }
334     #include "opts.def"
335
336     /* optimizations */
337     #define GMQCC_TYPE_OPTIMIZATIONS
338     #define GMQCC_DEFINE_FLAG(X,Y)                                     \
339     if (!strcmp(section, "optimizations") && !strcmp(name, #X)) {      \
340         opts_set(opts.optimization, OPTIM_##X, opts_ini_bool(value));  \
341         found = true;                                                  \
342     }
343     #include "opts.def"
344
345     /* nothing was found ever! */
346     if (!found) {
347         if (strcmp(section, "flags")         &&
348             strcmp(section, "warnings")      &&
349             strcmp(section, "optimizations"))
350         {
351             vec_upload(error, "invalid section `", 17);
352             vec_upload(error, section, strlen(section));
353             vec_push  (error, '`');
354             vec_push  (error, '\0');
355         } else {
356             vec_upload(error, "invalid variable `", 18);
357             vec_upload(error, name, strlen(name));
358             vec_push  (error, '`');
359             vec_upload(error, " in section: `", 14);
360             vec_upload(error, section, strlen(section));
361             vec_push  (error, '`');
362             vec_push  (error, '\0');
363         }
364     }
365     return error;
366 }
367
368 /*
369  * Actual loading subsystem, this finds the ini or cfg file, and properly
370  * loads it and executes it to set compiler options.
371  */
372 void opts_ini_init(const char *file) {
373     /*
374      * Possible matches are:
375      *  gmqcc.ini
376      *  gmqcc.cfg
377      */
378     char       *error = NULL;
379     size_t     line;
380     FILE       *ini;
381
382     if (!file) {
383         /* try ini */
384         if (!(ini = fs_file_open((file = "gmqcc.ini"), "r")))
385             /* try cfg */
386             if (!(ini = fs_file_open((file = "gmqcc.cfg"), "r")))
387                 return;
388     } else if (!(ini = fs_file_open(file, "r")))
389         return;
390
391     con_out("found ini file `%s`\n", file);
392
393     if ((line = opts_ini_parse(ini, &opts_ini_load, &error)) != 0) {
394         /* there was a parse error with the ini file */
395         con_printmsg(LVL_ERROR, file, line, 0 /*TODO: column for ini error*/, "error", error);
396         vec_free(error);
397     }
398
399     fs_file_close(ini);
400 }