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