opts.c

   1 /*
   2  * Copyright (C) 2012, 2013, 2014, 2015
   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 line options */
  59
  60 static void opts_setdefault(void) {
  61     memset(&opts, 0, sizeof(opts_cmd_t));
  62     OPTS_OPTION_STR(OPTION_PROGSRC)     = "progs.src";
  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     opts_set(opts.warn,  WARN_CONST_OVERWRITE,           true);
  93     opts_set(opts.warn,  WARN_DIRECTIVE_INMACRO,         true);
  94     opts_set(opts.warn,  WARN_BUILTINS,                  true);
  95     opts_set(opts.warn,  WARN_INEXACT_COMPARES,          true);
  96
  97     /* flags */
  98     opts_set(opts.flags, ADJUST_VECTOR_FIELDS,           true);
  99     opts_set(opts.flags, CORRECT_TERNARY,                true);
 100     opts_set(opts.flags, BAIL_ON_WERROR,                 true);
 101     opts_set(opts.flags, LEGACY_VECTOR_MATHS,            true);
 102     opts_set(opts.flags, DARKPLACES_STRING_TABLE_BUG,    true);
 103
 104     /* options */
 105     OPTS_OPTION_U32(OPTION_STATE_FPS) = 10;
 106 }
 107
 108 void opts_backup_non_Wall() {
 109     size_t i;
 110     for (i = 0; i <= WARN_DEBUG; ++i)
 111         opts_set(opts.warn_backup, i, OPTS_WARN(i));
 112 }
 113
 114 void opts_restore_non_Wall() {
 115     size_t i;
 116     for (i = 0; i <= WARN_DEBUG; ++i)
 117         opts_set(opts.warn, i, OPTS_GENERIC(opts.warn_backup, i));
 118 }
 119
 120 void opts_backup_non_Werror_all() {
 121     size_t i;
 122     for (i = 0; i <= WARN_DEBUG; ++i)
 123         opts_set(opts.werror_backup, i, OPTS_WERROR(i));
 124 }
 125
 126 void opts_restore_non_Werror_all() {
 127     size_t i;
 128     for (i = 0; i <= WARN_DEBUG; ++i)
 129         opts_set(opts.werror, i, OPTS_GENERIC(opts.werror_backup, i));
 130 }
 131
 132 void opts_init(const char *output, int standard, size_t arraysize) {
 133     opts_setdefault();
 134
 135     OPTS_OPTION_STR(OPTION_OUTPUT)         = output;
 136     OPTS_OPTION_U32(OPTION_STANDARD)       = standard;
 137     OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE) = arraysize;
 138     OPTS_OPTION_U16(OPTION_MEMDUMPCOLS)    = 16;
 139 }
 140
 141 static bool opts_setflag_all(const char *name, bool on, uint32_t *flags, const opts_flag_def_t *list, size_t listsize) {
 142     size_t i;
 143
 144     for (i = 0; i < listsize; ++i) {
 145         if (!strcmp(name, list[i].name)) {
 146             longbit lb = list[i].bit;
 147
 148             if (on)
 149                 flags[lb.idx] |= (1<<(lb.bit));
 150             else
 151                 flags[lb.idx] &= ~(1<<(lb.bit));
 152
 153             return true;
 154         }
 155     }
 156     return false;
 157 }
 158 bool opts_setflag  (const char *name, bool on) {
 159     return opts_setflag_all(name, on, opts.flags,        opts_flag_list, COUNT_FLAGS);
 160 }
 161 bool opts_setwarn  (const char *name, bool on) {
 162     return opts_setflag_all(name, on, opts.warn,         opts_warn_list, COUNT_WARNINGS);
 163 }
 164 bool opts_setwerror(const char *name, bool on) {
 165     return opts_setflag_all(name, on, opts.werror,       opts_warn_list, COUNT_WARNINGS);
 166 }
 167 bool opts_setoptim (const char *name, bool on) {
 168     return opts_setflag_all(name, on, opts.optimization, opts_opt_list,  COUNT_OPTIMIZATIONS);
 169 }
 170
 171 void opts_set(uint32_t *flags, size_t idx, bool on) {
 172     longbit lb;
 173     LONGBIT_SET(lb, idx);
 174
 175     if (on)
 176         flags[lb.idx] |= (1<<(lb.bit));
 177     else
 178         flags[lb.idx] &= ~(1<<(lb.bit));
 179 }
 180
 181 void opts_setoptimlevel(unsigned int level) {
 182     size_t i;
 183     for (i = 0; i < COUNT_OPTIMIZATIONS; ++i)
 184         opts_set(opts.optimization, i, level >= opts_opt_oflag[i]);
 185
 186     if (!level)
 187         opts.optimizeoff = true;
 188 }
 189
 190 /*
 191  * Standard configuration parser and subsystem.  Yes, optionally you may
 192  * create ini files or cfg (the driver accepts both) for a project opposed
 193  * to supplying just a progs.src (since you also may need to supply command
 194  * line arguments or set the options of the compiler) [which cannot be done
 195  * from a progs.src.
 196  */
 197 static char *opts_ini_rstrip(char *s) {
 198     char *p = s + strlen(s) - 1;
 199     while (p > s && util_isspace(*p))
 200         *p = '\0', p--;
 201     return s;
 202 }
 203
 204 static char *opts_ini_lskip(const char *s) {
 205     while (*s && util_isspace(*s))
 206         s++;
 207     return (char*)s;
 208 }
 209
 210 static char *opts_ini_next(const char *s, char c) {
 211     bool last = false;
 212     while (*s && *s != c && !(last && *s == ';'))
 213         last = !!util_isspace(*s), s++;
 214
 215     return (char*)s;
 216 }
 217
 218 static size_t opts_ini_parse (
 219     fs_file_t *filehandle,
 220     char *(*loadhandle)(const char *, const char *, const char *, char **),
 221     char **errorhandle,
 222     char **parse_file
 223 ) {
 224     size_t linesize;
 225     size_t lineno             = 1;
 226     size_t error              = 0;
 227     char  *line               = NULL;
 228     char   section_data[2048] = "";
 229     char   oldname_data[2048] = "";
 230
 231     /* parsing and reading variables */
 232     char *parse_beg;
 233     char *parse_end;
 234     char *read_name;
 235     char *read_value;
 236
 237     while (fs_file_getline(&line, &linesize, filehandle) != FS_FILE_EOF) {
 238         parse_beg = line;
 239
 240         /* handle BOM */
 241         if (lineno == 1 && (
 242                 (unsigned char)parse_beg[0] == 0xEF &&
 243                 (unsigned char)parse_beg[1] == 0xBB &&
 244                 (unsigned char)parse_beg[2] == 0xBF
 245             )
 246         ) {
 247             parse_beg ++; /* 0xEF */
 248             parse_beg ++; /* 0xBB */
 249             parse_beg ++; /* 0xBF */
 250         }
 251
 252         if (*(parse_beg = opts_ini_lskip(opts_ini_rstrip(parse_beg))) == ';' || *parse_beg == '#') {
 253             /* ignore '#' is a perl extension */
 254         } else if (*parse_beg == '[') {
 255             /* section found */
 256             if (*(parse_end = opts_ini_next(parse_beg + 1, ']')) == ']') {
 257                 * parse_end = '\0'; /* terminate bro */
 258                 util_strncpy(section_data, parse_beg + 1, sizeof(section_data));
 259                 section_data[sizeof(section_data) - 1] = '\0';
 260                 *oldname_data                          = '\0';
 261             } else if (!error) {
 262                 /* otherwise set error to the current line number */
 263                 error = lineno;
 264             }
 265         } else if (*parse_beg && *parse_beg != ';') {
 266             /* not a comment, must be a name value pair :) */
 267             if (*(parse_end = opts_ini_next(parse_beg, '=')) != '=')
 268                 parse_end = opts_ini_next(parse_beg, ':');
 269
 270             if (*parse_end == '=' || *parse_end == ':') {
 271                 *parse_end = '\0'; /* terminate bro */
 272                 read_name  = opts_ini_rstrip(parse_beg);
 273                 read_value = opts_ini_lskip(parse_end + 1);
 274                 if (*(parse_end = opts_ini_next(read_value, '\0')) == ';')
 275                     * parse_end = '\0';
 276                 opts_ini_rstrip(read_value);
 277
 278                 /* valid name value pair, lets call down to handler */
 279                 util_strncpy(oldname_data, read_name, sizeof(oldname_data));
 280                 oldname_data[sizeof(oldname_data) - 1] ='\0';
 281
 282                 if ((*errorhandle = loadhandle(section_data, read_name, read_value, parse_file)) && !error)
 283                     error = lineno;
 284             } else if (!strcmp(section_data, "includes")) {
 285                 /* Includes are special */
 286                 if (*(parse_end = opts_ini_next(parse_beg, '=')) == '='
 287                 ||  *(parse_end = opts_ini_next(parse_beg, ':')) == ':') {
 288                     static const char *invalid_include = "invalid use of include";
 289                     vec_append(*errorhandle, strlen(invalid_include), invalid_include);
 290                     error = lineno;
 291                 } else {
 292                     read_name = opts_ini_rstrip(parse_beg);
 293                     if ((*errorhandle = loadhandle(section_data, read_name, read_name, parse_file)) && !error)
 294                         error = lineno;
 295                 }
 296             } else if (!error) {
 297                 /* otherwise set error to the current line number */
 298                 error = lineno;
 299             }
 300         }
 301         lineno++;
 302     }
 303     mem_d(line);
 304     return error;
 305
 306 }
 307
 308 /*
 309  * returns true/false for a char that contains ("true" or "false" or numeric 0/1)
 310  */
 311 static bool opts_ini_bool(const char *value) {
 312     if (!strcmp(value, "true"))  return true;
 313     if (!strcmp(value, "false")) return false;
 314     return !!strtol(value, NULL, 10);
 315 }
 316
 317 static char *opts_ini_load(const char *section, const char *name, const char *value, char **parse_file) {
 318     char *error = NULL;
 319     bool  found = false;
 320
 321     /*
 322      * undef all of these because they may still be defined like in my
 323      * case they where.
 324      */
 325     #undef GMQCC_TYPE_FLAGS
 326     #undef GMQCC_TYPE_OPTIMIZATIONS
 327     #undef GMQCC_TYPE_WARNS
 328
 329     /* deal with includes */
 330     if (!strcmp(section, "includes")) {
 331         static const char *include_error_beg = "failed to open file `";
 332         static const char *include_error_end = "' for inclusion";
 333         fs_file_t *file = fs_file_open(value, "r");
 334         found = true;
 335         if (!file) {
 336             vec_append(error, strlen(include_error_beg), include_error_beg);
 337             vec_append(error, strlen(value), value);
 338             vec_append(error, strlen(include_error_end), include_error_end);
 339         } else {
 340             if (opts_ini_parse(file, &opts_ini_load, &error, parse_file) != 0)
 341                 found = false;
 342             /* Change the file name */
 343             mem_d(*parse_file);
 344             *parse_file = util_strdup(value);
 345             fs_file_close(file);
 346         }
 347     }
 348
 349     /* flags */
 350     #define GMQCC_TYPE_FLAGS
 351     #define GMQCC_DEFINE_FLAG(X)                                       \
 352     if (!strcmp(section, "flags") && !strcmp(name, #X)) {              \
 353         opts_set(opts.flags, X, opts_ini_bool(value));                 \
 354         found = true;                                                  \
 355     }
 356     #include "opts.def"
 357
 358     /* warnings */
 359     #define GMQCC_TYPE_WARNS
 360     #define GMQCC_DEFINE_FLAG(X)                                       \
 361     if (!strcmp(section, "warnings") && !strcmp(name, #X)) {           \
 362         opts_set(opts.warn, WARN_##X, opts_ini_bool(value));           \
 363         found = true;                                                  \
 364     }
 365     #include "opts.def"
 366
 367     /* Werror-individuals */
 368     #define GMQCC_TYPE_WARNS
 369     #define GMQCC_DEFINE_FLAG(X)                                       \
 370     if (!strcmp(section, "errors") && !strcmp(name, #X)) {             \
 371         opts_set(opts.werror, WARN_##X, opts_ini_bool(value));         \
 372         found = true;                                                  \
 373     }
 374     #include "opts.def"
 375
 376     /* optimizations */
 377     #define GMQCC_TYPE_OPTIMIZATIONS
 378     #define GMQCC_DEFINE_FLAG(X,Y)                                     \
 379     if (!strcmp(section, "optimizations") && !strcmp(name, #X)) {      \
 380         opts_set(opts.optimization, OPTIM_##X, opts_ini_bool(value));  \
 381         found = true;                                                  \
 382     }
 383     #include "opts.def"
 384
 385     /* nothing was found ever! */
 386     if (!found) {
 387         if (strcmp(section, "includes") &&
 388             strcmp(section, "flags")    &&
 389             strcmp(section, "warnings") &&
 390             strcmp(section, "optimizations"))
 391         {
 392             static const char *invalid_section = "invalid_section `";
 393             vec_append(error, strlen(invalid_section), invalid_section);
 394             vec_append(error, strlen(section), section);
 395             vec_push(error, '`');
 396         } else if (strcmp(section, "includes")) {
 397             static const char *invalid_variable = "invalid_variable `";
 398             static const char *in_section = "` in section: `";
 399             vec_append(error, strlen(invalid_variable), invalid_variable);
 400             vec_append(error, strlen(name), name);
 401             vec_append(error, strlen(in_section), in_section);
 402             vec_append(error, strlen(section), section);
 403             vec_push(error, '`');
 404         } else {
 405             static const char *expected_something = "expected something";
 406             vec_append(error, strlen(expected_something), expected_something);
 407         }
 408     }
 409     vec_push(error, '\0');
 410     return error;
 411 }
 412
 413 /*
 414  * Actual loading subsystem, this finds the ini or cfg file, and properly
 415  * loads it and executes it to set compiler options.
 416  */
 417 void opts_ini_init(const char *file) {
 418     /*
 419      * Possible matches are:
 420      *  gmqcc.ini
 421      *  gmqcc.cfg
 422      */
 423     char       *error = NULL;
 424     char       *parse_file = NULL;
 425     size_t     line;
 426     fs_file_t  *ini;
 427
 428     if (!file) {
 429         /* try ini */
 430         if (!(ini = fs_file_open((file = "gmqcc.ini"), "r")))
 431             /* try cfg */
 432             if (!(ini = fs_file_open((file = "gmqcc.cfg"), "r")))
 433                 return;
 434     } else if (!(ini = fs_file_open(file, "r")))
 435         return;
 436
 437     con_out("found ini file `%s`\n", file);
 438
 439     parse_file = util_strdup(file);
 440     if ((line = opts_ini_parse(ini, &opts_ini_load, &error, &parse_file)) != 0) {
 441         /* there was a parse error with the ini file */
 442         con_printmsg(LVL_ERROR, parse_file, line, 0 /*TODO: column for ini error*/, "error", error);
 443         vec_free(error);
 444     }
 445     mem_d(parse_file);
 446
 447     fs_file_close(ini);
 448 }