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