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 typedef struct { char *filename; int type; } argitem;
  36 VECTOR_MAKE(argitem, items);
  37
  38 #define TYPE_QC  0
  39 #define TYPE_ASM 1
  40 #define TYPE_SRC 2
  41
  42 static const char *app_name;
  43
  44 static int usage() {
  45     printf("usage: %s [options] [files...]", app_name);
  46     printf("options:\n"
  47            "  -h, --help             show this help message\n"
  48            "  -debug                 turns on compiler debug messages\n"
  49            "  -memchk                turns on compiler memory leak check\n");
  50     printf("  -o, --output=file      output file, defaults to progs.dat\n"
  51            "  -a filename            add an asm file to be assembled\n"
  52            "  -s filename            add a progs.src file to be used\n");
  53     printf("  -f<flag>               enable a flag\n"
  54            "  -fno-<flag>            disable a flag\n"
  55            "  -std standard          select one of the following standards\n"
  56            "       -std=qcc          original QuakeC\n"
  57            "       -std=fteqcc       fteqcc QuakeC\n"
  58            "       -std=gmqcc        this compiler (default)\n");
  59     printf("  -W<warning>            enable a warning\n"
  60            "  -Wno-<warning>         disable a warning\n"
  61            "  -Wall                  enable all warnings\n");
  62     printf("\n");
  63     printf("flags:\n"
  64            "  -fdarkplaces-string-table-bug\n"
  65            "            patch the string table to work with some bugged darkplaces versions\n"
  66            "  -fomit-nullbytes\n"
  67            "            omits certain null-bytes for a smaller output - requires a patched engine\n"
  68            );
  69     return -1;
  70 }
  71
  72 static bool options_setflag_all(const char *name, bool on, uint32_t *flags, const opts_flag_def *list, size_t listsize) {
  73     size_t i;
  74
  75     for (i = 0; i < listsize; ++i) {
  76         if (!strcmp(name, list[i].name)) {
  77             longbit lb = list[i].bit;
  78 #if 0
  79             if (on)
  80                 flags[lb.idx] |= (1<<(lb.bit));
  81             else
  82                 flags[lb.idx] &= ~(1<<(lb.bit));
  83 #else
  84             if (on)
  85                 flags[0] |= (1<<lb);
  86             else
  87                 flags[0] &= ~(1<<(lb));
  88 #endif
  89             return true;
  90         }
  91     }
  92     return false;
  93 }
  94 static bool options_setflag(const char *name, bool on) {
  95     return options_setflag_all(name, on, opts_flags, opts_flag_list, COUNT_FLAGS);
  96 }
  97 static bool options_setwarn(const char *name, bool on) {
  98     return options_setflag_all(name, on, opts_warn, opts_warn_list, COUNT_WARNINGS);
  99 }
 100
 101 static bool options_witharg(int *argc_, char ***argv_, char **out) {
 102     int  argc   = *argc_;
 103     char **argv = *argv_;
 104
 105     if (argv[0][2]) {
 106         *out = argv[0]+2;
 107         return true;
 108     }
 109     /* eat up the next */
 110     if (argc < 2) /* no parameter was provided */
 111         return false;
 112
 113     *out = argv[1];
 114     --*argc_;
 115     ++*argv_;
 116     return true;
 117 }
 118
 119 static bool options_long_witharg_all(const char *optname, int *argc_, char ***argv_, char **out, int ds, bool split) {
 120     int  argc   = *argc_;
 121     char **argv = *argv_;
 122
 123     size_t len = strlen(optname);
 124
 125     if (strncmp(argv[0]+ds, optname, len))
 126         return false;
 127
 128     /* it's --optname, check how the parameter is supplied */
 129     if (argv[0][ds+len] == '=') {
 130         /* using --opt=param */
 131         *out = argv[0]+ds+len+1;
 132         return true;
 133     }
 134
 135     if (!split || argc < ds) /* no parameter was provided, or only single-arg form accepted */
 136         return false;
 137
 138     /* using --opt param */
 139     *out = argv[1];
 140     --*argc_;
 141     ++*argv_;
 142     return true;
 143 }
 144 static bool options_long_witharg(const char *optname, int *argc_, char ***argv_, char **out) {
 145     return options_long_witharg_all(optname, argc_, argv_, out, 2, true);
 146 }
 147 static bool options_long_gcc(const char *optname, int *argc_, char ***argv_, char **out) {
 148     return options_long_witharg_all(optname, argc_, argv_, out, 1, false);
 149 }
 150
 151 static bool options_parse(int argc, char **argv) {
 152     bool argend = false;
 153     size_t itr;
 154     char buffer[1024];
 155     while (!argend && argc > 1) {
 156         char *argarg;
 157         argitem item;
 158
 159         ++argv;
 160         --argc;
 161
 162         if (argv[0][0] == '-') {
 163     /* All gcc-type long options */
 164             if (options_long_gcc("std", &argc, &argv, &argarg)) {
 165                 if      (!strcmp(argarg, "gmqcc") || !strcmp(argarg, "default"))
 166                     opts_standard = COMPILER_GMQCC;
 167                 else if (!strcmp(argarg, "qcc"))
 168                     opts_standard = COMPILER_QCC;
 169                 else if (!strcmp(argarg, "fte") || !strcmp(argarg, "fteqcc"))
 170                     opts_standard = COMPILER_FTEQCC;
 171                 else if (!strcmp(argarg, "qccx"))
 172                     opts_standard = COMPILER_QCCX;
 173                 else {
 174                     printf("Unknown standard: %s\n", argarg);
 175                     return false;
 176                 }
 177                 continue;
 178             }
 179             if (!strcmp(argv[0]+1, "debug")) {
 180                 opts_debug = true;
 181                 continue;
 182             }
 183             if (!strcmp(argv[0]+1, "dump")) {
 184                 opts_dump = true;
 185                 continue;
 186             }
 187             if (!strcmp(argv[0]+1, "memchk")) {
 188                 opts_memchk = true;
 189                 continue;
 190             }
 191
 192             switch (argv[0][1]) {
 193                 /* -h, show usage but exit with 0 */
 194                 case 'h':
 195                     usage();
 196                     exit(0);
 197                     break;
 198
 199                 /* handle all -fflags */
 200                 case 'f':
 201                     util_strtocmd(argv[0]+2, argv[0]+2, strlen(argv[0]+2)+1);
 202                     if (!strcmp(argv[0]+2, "HELP")) {
 203                         printf("Possible flags:\n");
 204                         for (itr = 0; itr < COUNT_FLAGS; ++itr) {
 205                             util_strtononcmd(opts_flag_list[itr].name, buffer, sizeof(buffer));
 206                             printf(" -f%s\n", buffer);
 207                         }
 208                         exit(0);
 209                     }
 210                     else if (!strncmp(argv[0]+2, "NO_", 3)) {
 211                         if (!options_setflag(argv[0]+5, false)) {
 212                             printf("unknown flag: %s\n", argv[0]+2);
 213                             return false;
 214                         }
 215                     }
 216                     else if (!options_setflag(argv[0]+2, true)) {
 217                         printf("unknown flag: %s\n", argv[0]+2);
 218                         return false;
 219                     }
 220                     break;
 221                 case 'W':
 222                     util_strtocmd(argv[0]+2, argv[0]+2, strlen(argv[0]+2)+1);
 223                     if (!strcmp(argv[0]+2, "HELP")) {
 224                         printf("Possible warnings:\n");
 225                         for (itr = 0; itr < COUNT_WARNINGS; ++itr) {
 226                             util_strtononcmd(opts_warn_list[itr].name, buffer, sizeof(buffer));
 227                             printf(" -W%s\n", buffer);
 228                         }
 229                         exit(0);
 230                     }
 231                     else if (!strcmp(argv[0]+2, "ALL")) {
 232                         for (itr = 0; itr < sizeof(opts_warn)/sizeof(opts_warn[0]); ++itr)
 233                             opts_warn[itr] = 0xFFFFFFFFL;
 234                         break;
 235                     }
 236                     if (!strncmp(argv[0]+2, "NO_", 3)) {
 237                         if (!options_setwarn(argv[0]+5, false)) {
 238                             printf("unknown warning: %s\n", argv[0]+2);
 239                             return false;
 240                         }
 241                     }
 242                     else if (!options_setwarn(argv[0]+2, true)) {
 243                         printf("unknown warning: %s\n", argv[0]+2);
 244                         return false;
 245                     }
 246                     break;
 247
 248                 case 'O':
 249                     if (!options_witharg(&argc, &argv, &argarg)) {
 250                         printf("option -O requires a numerical argument\n");
 251                         return false;
 252                     }
 253                     opts_O = atoi(argarg);
 254                     break;
 255
 256                 case 'o':
 257                     if (!options_witharg(&argc, &argv, &argarg)) {
 258                         printf("option -o requires an argument: the output file name\n");
 259                         return false;
 260                     }
 261                     opts_output = argarg;
 262                     break;
 263
 264                 case 'a':
 265                 case 's':
 266                     item.type = argv[0][1] == 'a' ? TYPE_ASM : TYPE_SRC;
 267                     if (!options_witharg(&argc, &argv, &argarg)) {
 268                         printf("option -a requires a filename %s\n",
 269                                 (argv[0][1] == 'a' ? "containing QC-asm" : "containing a progs.src formatted list"));
 270                         return false;
 271                     }
 272                     item.filename = argarg;
 273                     items_add(item);
 274                     break;
 275
 276                 case '-':
 277                     if (!argv[0][2]) {
 278                         /* anything following -- is considered a non-option argument */
 279                         argend = true;
 280                         break;
 281                     }
 282             /* All long options without arguments */
 283                     else if (!strcmp(argv[0]+2, "help")) {
 284                         usage();
 285                         exit(0);
 286                     }
 287                     else {
 288             /* All long options with arguments */
 289                         if (options_long_witharg("output", &argc, &argv, &argarg))
 290                             opts_output = argarg;
 291                         else
 292                         {
 293                             printf("Unknown parameter: %s\n", argv[0]);
 294                             return false;
 295                         }
 296                     }
 297                     break;
 298
 299                 default:
 300                     printf("Unknown parameter: %s\n", argv[0]);
 301                     return false;
 302             }
 303         }
 304         else
 305         {
 306             /* it's a QC filename */
 307             argitem item;
 308             item.filename = argv[0];
 309             item.type     = TYPE_QC;
 310             items_add(item);
 311         }
 312     }
 313     return true;
 314 }
 315
 316 static void options_set(uint32_t *flags, size_t idx, bool on)
 317 {
 318     longbit lb = LONGBIT(idx);
 319 #if 0
 320     if (on)
 321         flags[lb.idx] |= (1<<(lb.bit));
 322     else
 323         flags[lb.idx] &= ~(1<<(lb.bit));
 324 #else
 325     if (on)
 326         flags[0] |= (1<<(lb));
 327     else
 328         flags[0] &= ~(1<<(lb));
 329 #endif
 330 }
 331
 332 bool parser_init();
 333 bool parser_compile(const char *filename);
 334 bool parser_finish(const char *output);
 335 void parser_cleanup();
 336
 337 int main(int argc, char **argv) {
 338     size_t itr;
 339     int retval = 0;
 340     app_name = argv[0];
 341
 342     /* default options / warn flags */
 343     options_set(opts_warn, WARN_UNKNOWN_CONTROL_SEQUENCE, true);
 344     options_set(opts_warn, WARN_EXTENSIONS, true);
 345
 346     if (!options_parse(argc, argv)) {
 347         return usage();
 348     }
 349
 350     if (opts_dump) {
 351         for (itr = 0; itr < COUNT_FLAGS; ++itr) {
 352             printf("Flag %s = %i\n", opts_flag_list[itr].name, OPTS_FLAG(itr));
 353         }
 354         for (itr = 0; itr < COUNT_WARNINGS; ++itr) {
 355             printf("Warning %s = %i\n", opts_warn_list[itr].name, OPTS_WARN(itr));
 356         }
 357         printf("output = %s\n", opts_output);
 358         printf("optimization level = %i\n", (int)opts_O);
 359         printf("standard = %i\n", opts_standard);
 360     }
 361
 362     if (!parser_init()) {
 363         printf("failed to initialize parser\n");
 364         goto cleanup;
 365     }
 366
 367     util_debug("COM", "starting ...\n");
 368
 369     if (items_elements) {
 370         printf("Mode: manual\n");
 371         printf("There are %lu items to compile:\n", (unsigned long)items_elements);
 372         for (itr = 0; itr < items_elements; ++itr) {
 373             printf("  item: %s (%s)\n",
 374                    items_data[itr].filename,
 375                    ( (items_data[itr].type == TYPE_QC ? "qc" :
 376                      (items_data[itr].type == TYPE_ASM ? "asm" :
 377                      (items_data[itr].type == TYPE_SRC ? "progs.src" :
 378                      ("unknown"))))));
 379
 380             if (!parser_compile(items_data[itr].filename)) {
 381                 retval = 1;
 382                 goto cleanup;
 383             }
 384         }
 385
 386         parser_finish(opts_output);
 387     } else {
 388         printf("Mode: progs.src - not implemented\n");
 389     }
 390
 391     /* stuff */
 392
 393 cleanup:
 394     util_debug("COM", "cleaning ...\n");
 395
 396     parser_cleanup();
 397
 398     util_meminfo();
 399     return retval;
 400 }