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