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