main.c

   1 /*
   2  * Copyright (C) 2012
   3  *     Dale Weiler
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   6  * this software and associated documentation files (the "Software"), to deal in
   7  * the Software without restriction, including without limitation the rights to
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is furnished to do
  10  * so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in all
  13  * copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23 #include "gmqcc.h"
  24
  25 uint32_t    opts_flags[1 + (COUNT_FLAGS / 32)];
  26 uint32_t    opts_warn [1 + (COUNT_WARNINGS / 32)];
  27
  28 uint32_t    opts_O        = 1;
  29 const char *opts_output   = "progs.dat";
  30 int         opts_standard = COMPILER_GMQCC;
  31 bool        opts_debug    = false;
  32 bool        opts_memchk   = false;
  33 bool        opts_dump     = false;
  34
  35 static bool opts_output_wasset = false;
  36
  37 typedef struct { char *filename; int type; } argitem;
  38 VECTOR_MAKE(argitem, items);
  39
  40 #define TYPE_QC  0
  41 #define TYPE_ASM 1
  42 #define TYPE_SRC 2
  43
  44 static const char *app_name;
  45
  46 static int usage() {
  47     printf("usage: %s [options] [files...]", app_name);
  48     printf("options:\n"
  49            "  -h, --help             show this help message\n"
  50            "  -debug                 turns on compiler debug messages\n"
  51            "  -memchk                turns on compiler memory leak check\n");
  52     printf("  -o, --output=file      output file, defaults to progs.dat\n"
  53            "  -a filename            add an asm file to be assembled\n"
  54            "  -s filename            add a progs.src file to be used\n");
  55     printf("  -f<flag>               enable a flag\n"
  56            "  -fno-<flag>            disable a flag\n"
  57            "  -std standard          select one of the following standards\n"
  58            "       -std=qcc          original QuakeC\n"
  59            "       -std=fteqcc       fteqcc QuakeC\n"
  60            "       -std=gmqcc        this compiler (default)\n");
  61     printf("  -W<warning>            enable a warning\n"
  62            "  -Wno-<warning>         disable a warning\n"
  63            "  -Wall                  enable all warnings\n");
  64     printf("\n");
  65     printf("flags:\n"
  66            "  -fdarkplaces-string-table-bug\n"
  67            "            patch the string table to work with some bugged darkplaces versions\n"
  68            "  -fomit-nullbytes\n"
  69            "            omits certain null-bytes for a smaller output - requires a patched engine\n"
  70            );
  71     return -1;
  72 }
  73
  74 static bool options_setflag_all(const char *name, bool on, uint32_t *flags, const opts_flag_def *list, size_t listsize) {
  75     size_t i;
  76
  77     for (i = 0; i < listsize; ++i) {
  78         if (!strcmp(name, list[i].name)) {
  79             longbit lb = list[i].bit;
  80 #if 0
  81             if (on)
  82                 flags[lb.idx] |= (1<<(lb.bit));
  83             else
  84                 flags[lb.idx] &= ~(1<<(lb.bit));
  85 #else
  86             if (on)
  87                 flags[0] |= (1<<lb);
  88             else
  89                 flags[0] &= ~(1<<(lb));
  90 #endif
  91             return true;
  92         }
  93     }
  94     return false;
  95 }
  96 static bool options_setflag(const char *name, bool on) {
  97     return options_setflag_all(name, on, opts_flags, opts_flag_list, COUNT_FLAGS);
  98 }
  99 static bool options_setwarn(const char *name, bool on) {
 100     return options_setflag_all(name, on, opts_warn, opts_warn_list, COUNT_WARNINGS);
 101 }
 102
 103 static bool options_witharg(int *argc_, char ***argv_, char **out) {
 104     int  argc   = *argc_;
 105     char **argv = *argv_;
 106
 107     if (argv[0][2]) {
 108         *out = argv[0]+2;
 109         return true;
 110     }
 111     /* eat up the next */
 112     if (argc < 2) /* no parameter was provided */
 113         return false;
 114
 115     *out = argv[1];
 116     --*argc_;
 117     ++*argv_;
 118     return true;
 119 }
 120
 121 static bool options_long_witharg_all(const char *optname, int *argc_, char ***argv_, char **out, int ds, bool split) {
 122     int  argc   = *argc_;
 123     char **argv = *argv_;
 124
 125     size_t len = strlen(optname);
 126
 127     if (strncmp(argv[0]+ds, optname, len))
 128         return false;
 129
 130     /* it's --optname, check how the parameter is supplied */
 131     if (argv[0][ds+len] == '=') {
 132         /* using --opt=param */
 133         *out = argv[0]+ds+len+1;
 134         return true;
 135     }
 136
 137     if (!split || argc < ds) /* no parameter was provided, or only single-arg form accepted */
 138         return false;
 139
 140     /* using --opt param */
 141     *out = argv[1];
 142     --*argc_;
 143     ++*argv_;
 144     return true;
 145 }
 146 static bool options_long_witharg(const char *optname, int *argc_, char ***argv_, char **out) {
 147     return options_long_witharg_all(optname, argc_, argv_, out, 2, true);
 148 }
 149 static bool options_long_gcc(const char *optname, int *argc_, char ***argv_, char **out) {
 150     return options_long_witharg_all(optname, argc_, argv_, out, 1, false);
 151 }
 152
 153 static bool options_parse(int argc, char **argv) {
 154     bool argend = false;
 155     size_t itr;
 156     char buffer[1024];
 157     while (!argend && argc > 1) {
 158         char *argarg;
 159         argitem item;
 160
 161         ++argv;
 162         --argc;
 163
 164         if (argv[0][0] == '-') {
 165     /* All gcc-type long options */
 166             if (options_long_gcc("std", &argc, &argv, &argarg)) {
 167                 if      (!strcmp(argarg, "gmqcc") || !strcmp(argarg, "default"))
 168                     opts_standard = COMPILER_GMQCC;
 169                 else if (!strcmp(argarg, "qcc"))
 170                     opts_standard = COMPILER_QCC;
 171                 else if (!strcmp(argarg, "fte") || !strcmp(argarg, "fteqcc"))
 172                     opts_standard = COMPILER_FTEQCC;
 173                 else if (!strcmp(argarg, "qccx"))
 174                     opts_standard = COMPILER_QCCX;
 175                 else {
 176                     printf("Unknown standard: %s\n", argarg);
 177                     return false;
 178                 }
 179                 continue;
 180             }
 181             if (!strcmp(argv[0]+1, "debug")) {
 182                 opts_debug = true;
 183                 continue;
 184             }
 185             if (!strcmp(argv[0]+1, "dump")) {
 186                 opts_dump = true;
 187                 continue;
 188             }
 189             if (!strcmp(argv[0]+1, "memchk")) {
 190                 opts_memchk = true;
 191                 continue;
 192             }
 193
 194             switch (argv[0][1]) {
 195                 /* -h, show usage but exit with 0 */
 196                 case 'h':
 197                     usage();
 198                     exit(0);
 199                     break;
 200
 201                 /* handle all -fflags */
 202                 case 'f':
 203                     util_strtocmd(argv[0]+2, argv[0]+2, strlen(argv[0]+2)+1);
 204                     if (!strcmp(argv[0]+2, "HELP")) {
 205                         printf("Possible flags:\n");
 206                         for (itr = 0; itr < COUNT_FLAGS; ++itr) {
 207                             util_strtononcmd(opts_flag_list[itr].name, buffer, sizeof(buffer));
 208                             printf(" -f%s\n", buffer);
 209                         }
 210                         exit(0);
 211                     }
 212                     else if (!strncmp(argv[0]+2, "NO_", 3)) {
 213                         if (!options_setflag(argv[0]+5, false)) {
 214                             printf("unknown flag: %s\n", argv[0]+2);
 215                             return false;
 216                         }
 217                     }
 218                     else if (!options_setflag(argv[0]+2, true)) {
 219                         printf("unknown flag: %s\n", argv[0]+2);
 220                         return false;
 221                     }
 222                     break;
 223                 case 'W':
 224                     util_strtocmd(argv[0]+2, argv[0]+2, strlen(argv[0]+2)+1);
 225                     if (!strcmp(argv[0]+2, "HELP")) {
 226                         printf("Possible warnings:\n");
 227                         for (itr = 0; itr < COUNT_WARNINGS; ++itr) {
 228                             util_strtononcmd(opts_warn_list[itr].name, buffer, sizeof(buffer));
 229                             printf(" -W%s\n", buffer);
 230                         }
 231                         exit(0);
 232                     }
 233                     else if (!strcmp(argv[0]+2, "ALL")) {
 234                         for (itr = 0; itr < sizeof(opts_warn)/sizeof(opts_warn[0]); ++itr)
 235                             opts_warn[itr] = 0xFFFFFFFFL;
 236                         break;
 237                     }
 238                     if (!strncmp(argv[0]+2, "NO_", 3)) {
 239                         if (!options_setwarn(argv[0]+5, false)) {
 240                             printf("unknown warning: %s\n", argv[0]+2);
 241                             return false;
 242                         }
 243                     }
 244                     else if (!options_setwarn(argv[0]+2, true)) {
 245                         printf("unknown warning: %s\n", argv[0]+2);
 246                         return false;
 247                     }
 248                     break;
 249
 250                 case 'O':
 251                     if (!options_witharg(&argc, &argv, &argarg)) {
 252                         printf("option -O requires a numerical argument\n");
 253                         return false;
 254                     }
 255                     opts_O = atoi(argarg);
 256                     break;
 257
 258                 case 'o':
 259                     if (!options_witharg(&argc, &argv, &argarg)) {
 260                         printf("option -o requires an argument: the output file name\n");
 261                         return false;
 262                     }
 263                     opts_output = argarg;
 264                     opts_output_wasset = true;
 265                     break;
 266
 267                 case 'a':
 268                 case 's':
 269                     item.type = argv[0][1] == 'a' ? TYPE_ASM : TYPE_SRC;
 270                     if (!options_witharg(&argc, &argv, &argarg)) {
 271                         printf("option -a requires a filename %s\n",
 272                                 (argv[0][1] == 'a' ? "containing QC-asm" : "containing a progs.src formatted list"));
 273                         return false;
 274                     }
 275                     item.filename = argarg;
 276                     items_add(item);
 277                     break;
 278
 279                 case '-':
 280                     if (!argv[0][2]) {
 281                         /* anything following -- is considered a non-option argument */
 282                         argend = true;
 283                         break;
 284                     }
 285             /* All long options without arguments */
 286                     else if (!strcmp(argv[0]+2, "help")) {
 287                         usage();
 288                         exit(0);
 289                     }
 290                     else {
 291             /* All long options with arguments */
 292                         if (options_long_witharg("output", &argc, &argv, &argarg)) {
 293                             opts_output = argarg;
 294                             opts_output_wasset = true;
 295                         } else {
 296                             printf("Unknown parameter: %s\n", argv[0]);
 297                             return false;
 298                         }
 299                     }
 300                     break;
 301
 302                 default:
 303                     printf("Unknown parameter: %s\n", argv[0]);
 304                     return false;
 305             }
 306         }
 307         else
 308         {
 309             /* it's a QC filename */
 310             argitem item;
 311             item.filename = argv[0];
 312             item.type     = TYPE_QC;
 313             items_add(item);
 314         }
 315     }
 316     return true;
 317 }
 318
 319 static void options_set(uint32_t *flags, size_t idx, bool on)
 320 {
 321     longbit lb = LONGBIT(idx);
 322 #if 0
 323     if (on)
 324         flags[lb.idx] |= (1<<(lb.bit));
 325     else
 326         flags[lb.idx] &= ~(1<<(lb.bit));
 327 #else
 328     if (on)
 329         flags[0] |= (1<<(lb));
 330     else
 331         flags[0] &= ~(1<<(lb));
 332 #endif
 333 }
 334
 335 /* returns the line number, or -1 on error */
 336 static bool progs_nextline(char **out, FILE *src)
 337 {
 338     size_t alen;
 339     int    len;
 340     char  *line;
 341     char  *start;
 342     char  *end;
 343
 344     line = *out;
 345     len = util_getline(&line, &alen, src);
 346     if (len == -1)
 347         return false;
 348
 349     /* start at first non-blank */
 350     for (start = line; isspace(*start); ++start) {}
 351     /* end at the first non-blank */
 352     for (end = start;  *end && !isspace(*end);  ++end)   {}
 353
 354     *out = line;
 355     /* move the actual filename to the beginning */
 356     while (start != end) {
 357         *line++ = *start++;
 358     }
 359     *line = 0;
 360     return true;
 361 }
 362
 363 int main(int argc, char **argv) {
 364     size_t itr;
 365     int retval = 0;
 366     bool opts_output_free = false;
 367
 368     app_name = argv[0];
 369
 370     /* default options / warn flags */
 371     options_set(opts_warn, WARN_UNKNOWN_CONTROL_SEQUENCE, true);
 372     options_set(opts_warn, WARN_EXTENSIONS, true);
 373
 374     if (!options_parse(argc, argv)) {
 375         return usage();
 376     }
 377
 378     if (opts_dump) {
 379         for (itr = 0; itr < COUNT_FLAGS; ++itr) {
 380             printf("Flag %s = %i\n", opts_flag_list[itr].name, OPTS_FLAG(itr));
 381         }
 382         for (itr = 0; itr < COUNT_WARNINGS; ++itr) {
 383             printf("Warning %s = %i\n", opts_warn_list[itr].name, OPTS_WARN(itr));
 384         }
 385         printf("output = %s\n", opts_output);
 386         printf("optimization level = %i\n", (int)opts_O);
 387         printf("standard = %i\n", opts_standard);
 388     }
 389
 390     if (!parser_init()) {
 391         printf("failed to initialize parser\n");
 392         retval = 1;
 393         goto cleanup;
 394     }
 395
 396     util_debug("COM", "starting ...\n");
 397
 398     if (items_elements) {
 399         printf("Mode: manual\n");
 400         printf("There are %lu items to compile:\n", (unsigned long)items_elements);
 401         for (itr = 0; itr < items_elements; ++itr) {
 402             printf("  item: %s (%s)\n",
 403                    items_data[itr].filename,
 404                    ( (items_data[itr].type == TYPE_QC ? "qc" :
 405                      (items_data[itr].type == TYPE_ASM ? "asm" :
 406                      (items_data[itr].type == TYPE_SRC ? "progs.src" :
 407                      ("unknown"))))));
 408
 409             if (!parser_compile(items_data[itr].filename)) {
 410                 retval = 1;
 411                 goto cleanup;
 412             }
 413         }
 414
 415         parser_finish(opts_output);
 416     } else {
 417         FILE *src;
 418         char *line;
 419
 420         printf("Mode: progs.src\n");
 421         src = fopen("progs.src", "rb");
 422         if (!src) {
 423             printf("failed to open `progs.src` for reading\n");
 424             retval = 1;
 425             goto cleanup;
 426         }
 427
 428         line = NULL;
 429         if (!progs_nextline(&line, src) || !line[0]) {
 430             printf("illformatted progs.src file: expected output filename in first line\n");
 431             retval = 1;
 432             goto srcdone;
 433         }
 434
 435         if (!opts_output_wasset) {
 436             opts_output = util_strdup(line);
 437             opts_output_free = true;
 438         }
 439
 440         while (progs_nextline(&line, src)) {
 441             if (!line[0] || (line[0] == '/' && line[1] == '/'))
 442                 continue;
 443             printf("  src: %s\n", line);
 444             if (!parser_compile(line)) {
 445                 retval = 1;
 446                 goto srcdone;
 447             }
 448         }
 449
 450         parser_finish(opts_output);
 451
 452 srcdone:
 453         fclose(src);
 454         mem_d(line);
 455     }
 456
 457     /* stuff */
 458
 459 cleanup:
 460     util_debug("COM", "cleaning ...\n");
 461
 462     parser_cleanup();
 463     if (opts_output_free)
 464         mem_d((char*)opts_output);
 465
 466     util_meminfo();
 467     return retval;
 468 }