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 #include "lexer.h"
  25
  26 uint32_t    opts_flags[1 + (COUNT_FLAGS / 32)];
  27 uint32_t    opts_warn [1 + (COUNT_WARNINGS / 32)];
  28
  29 uint32_t    opts_O        = 1;
  30 const char *opts_output   = "progs.dat";
  31 int         opts_standard = COMPILER_GMQCC;
  32 bool        opts_debug    = false;
  33 bool        opts_memchk   = false;
  34 bool        opts_dump     = false;
  35 bool        opts_werror   = false;
  36 bool        opts_forcecrc = false;
  37 bool        opts_pp_only  = false;
  38
  39 uint16_t    opts_forced_crc;
  40
  41 static bool opts_output_wasset = false;
  42
  43 /* set by the standard */
  44 const oper_info *operators      = NULL;
  45 size_t           operator_count = 0;
  46
  47 typedef struct { char *filename; int type; } argitem;
  48 VECTOR_MAKE(argitem, items);
  49
  50 #define TYPE_QC  0
  51 #define TYPE_ASM 1
  52 #define TYPE_SRC 2
  53
  54 static const char *app_name;
  55
  56 static int usage() {
  57     printf("usage: %s [options] [files...]", app_name);
  58     printf("options:\n"
  59            "  -h, --help             show this help message\n"
  60            "  -debug                 turns on compiler debug messages\n"
  61            "  -memchk                turns on compiler memory leak check\n");
  62     printf("  -o, --output=file      output file, defaults to progs.dat\n"
  63            "  -a filename            add an asm file to be assembled\n"
  64            "  -s filename            add a progs.src file to be used\n");
  65     printf("  -E                     stop after preprocessing\n");
  66     printf("  -f<flag>               enable a flag\n"
  67            "  -fno-<flag>            disable a flag\n"
  68            "  -std standard          select one of the following standards\n"
  69            "       -std=qcc          original QuakeC\n"
  70            "       -std=fteqcc       fteqcc QuakeC\n"
  71            "       -std=gmqcc        this compiler (default)\n");
  72     printf("  -W<warning>            enable a warning\n"
  73            "  -Wno-<warning>         disable a warning\n"
  74            "  -Wall                  enable all warnings\n"
  75            "  -Werror                treat warnings as errors\n");
  76     printf("  -force-crc=num         force a specific checksum into the header\n");
  77     printf("\n");
  78     printf("flags:\n"
  79            "  -fadjust-vector-fields\n"
  80            "            when assigning a vector field, its _y and _z fields also get assigned\n"
  81            );
  82     return -1;
  83 }
  84
  85 static bool options_setflag_all(const char *name, bool on, uint32_t *flags, const opts_flag_def *list, size_t listsize) {
  86     size_t i;
  87
  88     for (i = 0; i < listsize; ++i) {
  89         if (!strcmp(name, list[i].name)) {
  90             longbit lb = list[i].bit;
  91 #if 0
  92             if (on)
  93                 flags[lb.idx] |= (1<<(lb.bit));
  94             else
  95                 flags[lb.idx] &= ~(1<<(lb.bit));
  96 #else
  97             if (on)
  98                 flags[0] |= (1<<lb);
  99             else
 100                 flags[0] &= ~(1<<(lb));
 101 #endif
 102             return true;
 103         }
 104     }
 105     return false;
 106 }
 107 static bool options_setflag(const char *name, bool on) {
 108     return options_setflag_all(name, on, opts_flags, opts_flag_list, COUNT_FLAGS);
 109 }
 110 static bool options_setwarn(const char *name, bool on) {
 111     return options_setflag_all(name, on, opts_warn, opts_warn_list, COUNT_WARNINGS);
 112 }
 113
 114 static bool options_witharg(int *argc_, char ***argv_, char **out) {
 115     int  argc   = *argc_;
 116     char **argv = *argv_;
 117
 118     if (argv[0][2]) {
 119         *out = argv[0]+2;
 120         return true;
 121     }
 122     /* eat up the next */
 123     if (argc < 2) /* no parameter was provided */
 124         return false;
 125
 126     *out = argv[1];
 127     --*argc_;
 128     ++*argv_;
 129     return true;
 130 }
 131
 132 static bool options_long_witharg_all(const char *optname, int *argc_, char ***argv_, char **out, int ds, bool split) {
 133     int  argc   = *argc_;
 134     char **argv = *argv_;
 135
 136     size_t len = strlen(optname);
 137
 138     if (strncmp(argv[0]+ds, optname, len))
 139         return false;
 140
 141     /* it's --optname, check how the parameter is supplied */
 142     if (argv[0][ds+len] == '=') {
 143         /* using --opt=param */
 144         *out = argv[0]+ds+len+1;
 145         return true;
 146     }
 147
 148     if (!split || argc < ds) /* no parameter was provided, or only single-arg form accepted */
 149         return false;
 150
 151     /* using --opt param */
 152     *out = argv[1];
 153     --*argc_;
 154     ++*argv_;
 155     return true;
 156 }
 157 static bool options_long_witharg(const char *optname, int *argc_, char ***argv_, char **out) {
 158     return options_long_witharg_all(optname, argc_, argv_, out, 2, true);
 159 }
 160 static bool options_long_gcc(const char *optname, int *argc_, char ***argv_, char **out) {
 161     return options_long_witharg_all(optname, argc_, argv_, out, 1, false);
 162 }
 163
 164 static void options_set(uint32_t *flags, size_t idx, bool on)
 165 {
 166     longbit lb = LONGBIT(idx);
 167 #if 0
 168     if (on)
 169         flags[lb.idx] |= (1<<(lb.bit));
 170     else
 171         flags[lb.idx] &= ~(1<<(lb.bit));
 172 #else
 173     if (on)
 174         flags[0] |= (1<<(lb));
 175     else
 176         flags[0] &= ~(1<<(lb));
 177 #endif
 178 }
 179
 180 static bool options_parse(int argc, char **argv) {
 181     bool argend = false;
 182     size_t itr;
 183     char buffer[1024];
 184     while (!argend && argc > 1) {
 185         char *argarg;
 186         argitem item;
 187
 188         ++argv;
 189         --argc;
 190
 191         if (argv[0][0] == '-') {
 192     /* All gcc-type long options */
 193             if (options_long_gcc("std", &argc, &argv, &argarg)) {
 194                 if      (!strcmp(argarg, "gmqcc") || !strcmp(argarg, "default")) {
 195                     options_set(opts_flags, ADJUST_VECTOR_FIELDS, true);
 196                     opts_standard = COMPILER_GMQCC;
 197                 } else if (!strcmp(argarg, "qcc")) {
 198                     options_set(opts_flags, ADJUST_VECTOR_FIELDS, false);
 199                     opts_standard = COMPILER_QCC;
 200                 } else if (!strcmp(argarg, "fte") || !strcmp(argarg, "fteqcc")) {
 201                     options_set(opts_flags, ADJUST_VECTOR_FIELDS, false);
 202                     opts_standard = COMPILER_FTEQCC;
 203                 } else if (!strcmp(argarg, "qccx")) {
 204                     options_set(opts_flags, ADJUST_VECTOR_FIELDS, false);
 205                     opts_standard = COMPILER_QCCX;
 206                 } else {
 207                     printf("Unknown standard: %s\n", argarg);
 208                     return false;
 209                 }
 210                 continue;
 211             }
 212             if (options_long_gcc("force-crc", &argc, &argv, &argarg)) {
 213                 opts_forcecrc = true;
 214                 opts_forced_crc = strtol(argarg, NULL, 0);
 215                 continue;
 216             }
 217             if (!strcmp(argv[0]+1, "debug")) {
 218                 opts_debug = true;
 219                 continue;
 220             }
 221             if (!strcmp(argv[0]+1, "dump")) {
 222                 opts_dump = true;
 223                 continue;
 224             }
 225             if (!strcmp(argv[0]+1, "memchk")) {
 226                 opts_memchk = true;
 227                 continue;
 228             }
 229
 230             switch (argv[0][1]) {
 231                 /* -h, show usage but exit with 0 */
 232                 case 'h':
 233                     usage();
 234                     exit(0);
 235                     break;
 236
 237                 case 'E':
 238                     opts_pp_only = true;
 239                     break;
 240
 241                 /* handle all -fflags */
 242                 case 'f':
 243                     util_strtocmd(argv[0]+2, argv[0]+2, strlen(argv[0]+2)+1);
 244                     if (!strcmp(argv[0]+2, "HELP")) {
 245                         printf("Possible flags:\n");
 246                         for (itr = 0; itr < COUNT_FLAGS; ++itr) {
 247                             util_strtononcmd(opts_flag_list[itr].name, buffer, sizeof(buffer));
 248                             printf(" -f%s\n", buffer);
 249                         }
 250                         exit(0);
 251                     }
 252                     else if (!strncmp(argv[0]+2, "NO_", 3)) {
 253                         if (!options_setflag(argv[0]+5, false)) {
 254                             printf("unknown flag: %s\n", argv[0]+2);
 255                             return false;
 256                         }
 257                     }
 258                     else if (!options_setflag(argv[0]+2, true)) {
 259                         printf("unknown flag: %s\n", argv[0]+2);
 260                         return false;
 261                     }
 262                     break;
 263                 case 'W':
 264                     util_strtocmd(argv[0]+2, argv[0]+2, strlen(argv[0]+2)+1);
 265                     if (!strcmp(argv[0]+2, "HELP")) {
 266                         printf("Possible warnings:\n");
 267                         for (itr = 0; itr < COUNT_WARNINGS; ++itr) {
 268                             util_strtononcmd(opts_warn_list[itr].name, buffer, sizeof(buffer));
 269                             printf(" -W%s\n", buffer);
 270                         }
 271                         exit(0);
 272                     }
 273                     else if (!strcmp(argv[0]+2, "NO_ERROR")) {
 274                         opts_werror = false;
 275                         break;
 276                     }
 277                     else if (!strcmp(argv[0]+2, "ERROR")) {
 278                         opts_werror = true;
 279                         break;
 280                     }
 281                     else if (!strcmp(argv[0]+2, "NONE")) {
 282                         for (itr = 0; itr < sizeof(opts_warn)/sizeof(opts_warn[0]); ++itr)
 283                             opts_warn[itr] = 0;
 284                         break;
 285                     }
 286                     else if (!strcmp(argv[0]+2, "ALL")) {
 287                         for (itr = 0; itr < sizeof(opts_warn)/sizeof(opts_warn[0]); ++itr)
 288                             opts_warn[itr] = 0xFFFFFFFFL;
 289                         break;
 290                     }
 291                     if (!strncmp(argv[0]+2, "NO_", 3)) {
 292                         if (!options_setwarn(argv[0]+5, false)) {
 293                             printf("unknown warning: %s\n", argv[0]+2);
 294                             return false;
 295                         }
 296                     }
 297                     else if (!options_setwarn(argv[0]+2, true)) {
 298                         printf("unknown warning: %s\n", argv[0]+2);
 299                         return false;
 300                     }
 301                     break;
 302
 303                 case 'O':
 304                     if (!options_witharg(&argc, &argv, &argarg)) {
 305                         printf("option -O requires a numerical argument\n");
 306                         return false;
 307                     }
 308                     opts_O = atoi(argarg);
 309                     break;
 310
 311                 case 'o':
 312                     if (!options_witharg(&argc, &argv, &argarg)) {
 313                         printf("option -o requires an argument: the output file name\n");
 314                         return false;
 315                     }
 316                     opts_output = argarg;
 317                     opts_output_wasset = true;
 318                     break;
 319
 320                 case 'a':
 321                 case 's':
 322                     item.type = argv[0][1] == 'a' ? TYPE_ASM : TYPE_SRC;
 323                     if (!options_witharg(&argc, &argv, &argarg)) {
 324                         printf("option -a requires a filename %s\n",
 325                                 (argv[0][1] == 'a' ? "containing QC-asm" : "containing a progs.src formatted list"));
 326                         return false;
 327                     }
 328                     item.filename = argarg;
 329                     items_add(item);
 330                     break;
 331
 332                 case '-':
 333                     if (!argv[0][2]) {
 334                         /* anything following -- is considered a non-option argument */
 335                         argend = true;
 336                         break;
 337                     }
 338             /* All long options without arguments */
 339                     else if (!strcmp(argv[0]+2, "help")) {
 340                         usage();
 341                         exit(0);
 342                     }
 343                     else {
 344             /* All long options with arguments */
 345                         if (options_long_witharg("output", &argc, &argv, &argarg)) {
 346                             opts_output = argarg;
 347                             opts_output_wasset = true;
 348                         } else {
 349                             printf("Unknown parameter: %s\n", argv[0]);
 350                             return false;
 351                         }
 352                     }
 353                     break;
 354
 355                 default:
 356                     printf("Unknown parameter: %s\n", argv[0]);
 357                     return false;
 358             }
 359         }
 360         else
 361         {
 362             /* it's a QC filename */
 363             argitem item;
 364             item.filename = argv[0];
 365             item.type     = TYPE_QC;
 366             items_add(item);
 367         }
 368     }
 369     return true;
 370 }
 371
 372 /* returns the line number, or -1 on error */
 373 static bool progs_nextline(char **out, size_t *alen,FILE *src)
 374 {
 375     int    len;
 376     char  *line;
 377     char  *start;
 378     char  *end;
 379
 380     line = *out;
 381     len = util_getline(&line, alen, src);
 382     if (len == -1)
 383         return false;
 384
 385     /* start at first non-blank */
 386     for (start = line; isspace(*start); ++start) {}
 387     /* end at the first non-blank */
 388     for (end = start;  *end && !isspace(*end);  ++end)   {}
 389
 390     *out = line;
 391     /* move the actual filename to the beginning */
 392     while (start != end) {
 393         *line++ = *start++;
 394     }
 395     *line = 0;
 396     return true;
 397 }
 398
 399 int main(int argc, char **argv) {
 400     size_t itr;
 401     int retval = 0;
 402     bool opts_output_free = false;
 403
 404     app_name = argv[0];
 405
 406     /* default options / warn flags */
 407     options_set(opts_warn, WARN_UNKNOWN_CONTROL_SEQUENCE, true);
 408     options_set(opts_warn, WARN_EXTENSIONS, true);
 409     options_set(opts_warn, WARN_FIELD_REDECLARED, true);
 410     options_set(opts_warn, WARN_TOO_FEW_PARAMETERS, true);
 411     options_set(opts_warn, WARN_MISSING_RETURN_VALUES, true);
 412     options_set(opts_warn, WARN_USED_UNINITIALIZED, true);
 413     options_set(opts_warn, WARN_LOCAL_CONSTANTS, true);
 414     options_set(opts_warn, WARN_VOID_VARIABLES, true);
 415     options_set(opts_warn, WARN_IMPLICIT_FUNCTION_POINTER, true);
 416     options_set(opts_warn, WARN_VARIADIC_FUNCTION, true);
 417     options_set(opts_warn, WARN_FRAME_MACROS, true);
 418     options_set(opts_warn, WARN_UNUSED_VARIABLE, true);
 419     options_set(opts_warn, WARN_EFFECTLESS_STATEMENT, true);
 420     options_set(opts_warn, WARN_END_SYS_FIELDS, true);
 421     options_set(opts_warn, WARN_ASSIGN_FUNCTION_TYPES, true);
 422
 423     options_set(opts_flags, ADJUST_VECTOR_FIELDS, true);
 424
 425     if (!options_parse(argc, argv)) {
 426         return usage();
 427     }
 428
 429     /* the standard decides which set of operators to use */
 430     if (opts_standard == COMPILER_GMQCC) {
 431         operators = c_operators;
 432         operator_count = c_operator_count;
 433     } else {
 434         operators = qcc_operators;
 435         operator_count = qcc_operator_count;
 436     }
 437
 438     if (opts_dump) {
 439         for (itr = 0; itr < COUNT_FLAGS; ++itr) {
 440             printf("Flag %s = %i\n", opts_flag_list[itr].name, OPTS_FLAG(itr));
 441         }
 442         for (itr = 0; itr < COUNT_WARNINGS; ++itr) {
 443             printf("Warning %s = %i\n", opts_warn_list[itr].name, OPTS_WARN(itr));
 444         }
 445         printf("output = %s\n", opts_output);
 446         printf("optimization level = %i\n", (int)opts_O);
 447         printf("standard = %i\n", opts_standard);
 448     }
 449
 450     if (!parser_init()) {
 451         printf("failed to initialize parser\n");
 452         retval = 1;
 453         goto cleanup;
 454     }
 455
 456     util_debug("COM", "starting ...\n");
 457
 458     if (items_elements) {
 459         printf("Mode: manual\n");
 460         printf("There are %lu items to compile:\n", (unsigned long)items_elements);
 461         for (itr = 0; itr < items_elements; ++itr) {
 462             printf("  item: %s (%s)\n",
 463                    items_data[itr].filename,
 464                    ( (items_data[itr].type == TYPE_QC ? "qc" :
 465                      (items_data[itr].type == TYPE_ASM ? "asm" :
 466                      (items_data[itr].type == TYPE_SRC ? "progs.src" :
 467                      ("unknown"))))));
 468
 469             if (!parser_compile(items_data[itr].filename)) {
 470                 retval = 1;
 471                 goto cleanup;
 472             }
 473         }
 474
 475         if (!parser_finish(opts_output)) {
 476             retval = 1;
 477             goto cleanup;
 478         }
 479
 480     } else {
 481         FILE *src;
 482         char *line;
 483         size_t linelen = 0;
 484
 485         printf("Mode: progs.src\n");
 486         src = util_fopen("progs.src", "rb");
 487         if (!src) {
 488             printf("failed to open `progs.src` for reading\n");
 489             retval = 1;
 490             goto cleanup;
 491         }
 492
 493         line = NULL;
 494         if (!progs_nextline(&line, &linelen, src) || !line[0]) {
 495             printf("illformatted progs.src file: expected output filename in first line\n");
 496             retval = 1;
 497             goto srcdone;
 498         }
 499
 500         if (!opts_output_wasset) {
 501             opts_output = util_strdup(line);
 502             opts_output_free = true;
 503         }
 504
 505         while (progs_nextline(&line, &linelen, src)) {
 506             if (!line[0] || (line[0] == '/' && line[1] == '/'))
 507                 continue;
 508             printf("  src: %s\n", line);
 509             if (!parser_compile(line)) {
 510                 retval = 1;
 511                 goto srcdone;
 512             }
 513         }
 514
 515         parser_finish(opts_output);
 516
 517 srcdone:
 518         fclose(src);
 519         mem_d(line);
 520     }
 521
 522     /* stuff */
 523
 524 cleanup:
 525     util_debug("COM", "cleaning ...\n");
 526
 527     mem_d(items_data);
 528
 529     parser_cleanup();
 530     if (opts_output_free)
 531         mem_d((char*)opts_output);
 532
 533     lex_cleanup();
 534     util_meminfo();
 535     return retval;
 536 }