/*
- * Copyright (C) 2012
+ * Copyright (C) 2012, 2013
* Dale Weiler
* Wolfgang Bumiller
*
*/
#include "gmqcc.h"
#include "lexer.h"
+#include <time.h>
/* TODO: cleanup this whole file .. it's a fuckign mess */
__DATE__,
__TIME__
);
+#ifdef GMQCC_GITINFO
+ con_out("git build: %s\n", GMQCC_GITINFO);
+#endif
}
static int usage() {
con_out(" -o, --output=file output file, defaults to progs.dat\n"
" -s filename add a progs.src file to be used\n");
con_out(" -E stop after preprocessing\n");
+ con_out(" -q, --quiet be less verbose\n");
con_out(" -config file use the specified ini file\n");
con_out(" -std=standard select one of the following standards\n"
" -std=qcc original QuakeC\n"
" -fhelp list possible flags\n");
con_out(" -W<warning> enable a warning\n"
" -Wno-<warning> disable a warning\n"
- " -Wall enable all warnings\n"
- " -Werror treat warnings as errors\n");
+ " -Wall enable all warnings\n");
+ con_out(" -Werror treat warnings as errors\n"
+ " -Werror-<warning> treat a warning as error\n"
+ " -Wno-error-<warning> opposite of the above\n");
con_out(" -Whelp list possible warnings\n");
con_out(" -O<number> optimization level\n"
" -O<name> enable specific optimization\n"
bool argend = false;
size_t itr;
char buffer[1024];
- char *redirout = (char*)stdout;
- char *redirerr = (char*)stderr;
+ char *redirout = NULL;
+ char *redirerr = NULL;
char *config = NULL;
while (!argend && argc > 1) {
if (options_long_gcc("std", &argc, &argv, &argarg)) {
if (!strcmp(argarg, "gmqcc") || !strcmp(argarg, "default")) {
- opts_set(opts.flags, ADJUST_VECTOR_FIELDS, true);
+ opts_set(opts.flags, ADJUST_VECTOR_FIELDS, true);
+ opts_set(opts.flags, CORRECT_LOGIC, true);
+ opts_set(opts.flags, FALSE_EMPTY_STRINGS, false);
+ opts_set(opts.flags, TRUE_EMPTY_STRINGS, true);
+ opts_set(opts.flags, LOOP_LABELS, true);
+ opts_set(opts.flags, TRANSLATABLE_STRINGS, true);
+ opts_set(opts.flags, INITIALIZED_NONCONSTANTS, true);
+ opts_set(opts.werror, WARN_INVALID_PARAMETER_COUNT, true);
+ opts_set(opts.werror, WARN_MISSING_RETURN_VALUES, true);
opts.standard = COMPILER_GMQCC;
} else if (!strcmp(argarg, "qcc")) {
opts_set(opts.flags, TRANSLATABLE_STRINGS, true);
opts_set(opts.flags, ADJUST_VECTOR_FIELDS, false);
opts_set(opts.flags, ASSIGN_FUNCTION_TYPES, true);
- opts_set(opts.warn, WARN_TERNARY_PRECEDENCE, true);
opts_set(opts.flags, CORRECT_TERNARY, false);
+ opts_set(opts.warn, WARN_TERNARY_PRECEDENCE, true);
opts.standard = COMPILER_FTEQCC;
} else if (!strcmp(argarg, "qccx")) {
/* show defaults (like pathscale) */
if (!strcmp(argv[0]+1, "show-defaults")) {
- size_t itr;
- char buffer[1024];
for (itr = 0; itr < COUNT_FLAGS; ++itr) {
if (!OPTS_FLAG(itr))
continue;
case 'E':
opts.pp_only = true;
+ opts_set(opts.flags, FTEPP_PREDEFS, true); /* predefs on for -E */
break;
/* debug turns on -flno */
case 'g':
opts_setflag("LNO", true);
+ opts.g = true;
+ break;
+
+ case 'q':
+ opts.quiet = true;
break;
case 'D':
}
exit(0);
}
- else if (!strcmp(argv[0]+2, "NO_ERROR")) {
- opts.werror = false;
+ else if (!strcmp(argv[0]+2, "NO_ERROR") ||
+ !strcmp(argv[0]+2, "NO_ERROR_ALL"))
+ {
+ for (itr = 0; itr < sizeof(opts.werror)/sizeof(opts.werror[0]); ++itr)
+ opts.werror[itr] = 0;
break;
}
- else if (!strcmp(argv[0]+2, "ERROR")) {
- opts.werror = true;
+ else if (!strcmp(argv[0]+2, "ERROR") ||
+ !strcmp(argv[0]+2, "ERROR_ALL"))
+ {
+ opts_backup_non_Werror_all();
+ for (itr = 0; itr < sizeof(opts.werror)/sizeof(opts.werror[0]); ++itr)
+ opts.werror[itr] = 0xFFFFFFFFL;
+ opts_restore_non_Werror_all();
break;
}
else if (!strcmp(argv[0]+2, "NONE")) {
break;
}
else if (!strcmp(argv[0]+2, "ALL")) {
+ opts_backup_non_Wall();
for (itr = 0; itr < sizeof(opts.warn)/sizeof(opts.warn[0]); ++itr)
opts.warn[itr] = 0xFFFFFFFFL;
+ opts_restore_non_Wall();
break;
}
- if (!strncmp(argv[0]+2, "NO_", 3)) {
+ else if (!strncmp(argv[0]+2, "ERROR_", 6)) {
+ if (!opts_setwerror(argv[0]+8, true)) {
+ con_out("unknown warning: %s\n", argv[0]+2);
+ return false;
+ }
+ }
+ else if (!strncmp(argv[0]+2, "NO_ERROR_", 9)) {
+ if (!opts_setwerror(argv[0]+11, false)) {
+ con_out("unknown warning: %s\n", argv[0]+2);
+ return false;
+ }
+ }
+ else if (!strncmp(argv[0]+2, "NO_", 3)) {
if (!opts_setwarn(argv[0]+5, false)) {
con_out("unknown warning: %s\n", argv[0]+2);
return false;
version();
exit(0);
}
+ else if (!strcmp(argv[0]+2, "quiet")) {
+ opts.quiet = true;
+ break;
+ }
else {
/* All long options with arguments */
if (options_long_witharg("output", &argc, &argv, &argarg)) {
char *end;
line = *out;
- len = util_getline(&line, alen, src);
+ len = file_getline(&line, alen, src);
if (len == -1)
return false;
con_init ();
opts_init("progs.dat", COMPILER_GMQCC, (1024 << 3));
+ util_seed(time(0));
+
if (!options_parse(argc, argv)) {
return usage();
}
+ if (OPTS_FLAG(TRUE_EMPTY_STRINGS) && OPTS_FLAG(FALSE_EMPTY_STRINGS)) {
+ con_err("-ftrue-empty-strings and -ffalse-empty-strings are mutually exclusive");
+ exit(EXIT_FAILURE);
+ }
+
/* the standard decides which set of operators to use */
if (opts.standard == COMPILER_GMQCC) {
operators = c_operators;
operators[operator_count-1].id != opid2(':','?'))
{
con_err("internal error: operator precedence table wasn't updated correctly!\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
operators_free = true;
- newops = mem_a(sizeof(operators[0]) * operator_count);
+ newops = (oper_info*)mem_a(sizeof(operators[0]) * operator_count);
memcpy(newops, operators, sizeof(operators[0]) * operator_count);
memcpy(&newops[operator_count-2], &operators[operator_count-1], sizeof(newops[0]));
memcpy(&newops[operator_count-1], &operators[operator_count-2], sizeof(newops[0]));
con_out("Flag %s = %i\n", opts_flag_list[itr].name, OPTS_FLAG(itr));
for (itr = 0; itr < COUNT_WARNINGS; ++itr)
con_out("Warning %s = %i\n", opts_warn_list[itr].name, OPTS_WARN(itr));
-
+
con_out("output = %s\n", opts.output);
con_out("optimization level = %d\n", opts.O);
con_out("standard = %i\n", opts.standard);
if (opts.pp_only) {
if (opts_output_wasset) {
- outfile = util_fopen(opts.output, "wb");
+ outfile = file_open(opts.output, "wb");
if (!outfile) {
con_err("failed to open `%s` for writing\n", opts.output);
retval = 1;
goto cleanup;
}
}
- else
- outfile = stdout;
+ else {
+ outfile = con_default_out();
+ }
}
if (!opts.pp_only) {
}
}
+ if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
+ type_not_instr[TYPE_STRING] = INSTR_NOT_F;
+
util_debug("COM", "starting ...\n");
/* add macros */
progs_src = true;
- src = util_fopen("progs.src", "rb");
+ src = file_open("progs.src", "rb");
if (!src) {
con_err("failed to open `progs.src` for reading\n");
retval = 1;
}
srcdone:
- fclose(src);
+ file_close(src);
mem_d(line);
}
goto cleanup;
if (vec_size(items)) {
- if (!opts.pp_only) {
+ if (!opts.quiet && !opts.pp_only) {
con_out("Mode: %s\n", (progs_src ? "progs.src" : "manual"));
con_out("There are %lu items to compile:\n", (unsigned long)vec_size(items));
}
for (itr = 0; itr < vec_size(items); ++itr) {
- if (!opts.pp_only) {
+ if (!opts.quiet && !opts.pp_only) {
con_out(" item: %s (%s)\n",
items[itr].filename,
( (items[itr].type == TYPE_QC ? "qc" :
}
out = ftepp_get();
if (out)
- fprintf(outfile, "%s", out);
+ file_printf(outfile, "%s", out);
ftepp_flush();
}
else {
}
data = ftepp_get();
if (vec_size(data)) {
- if (!parser_compile_string_len(items[itr].filename, data, vec_size(data))) {
+ if (!parser_compile_string(items[itr].filename, data, vec_size(data))) {
retval = 1;
goto cleanup;
}
}
/* stuff */
- if (!opts.pp_only) {
+ if (!opts.quiet && !opts.pp_only) {
for (itr = 0; itr < COUNT_OPTIMIZATIONS; ++itr) {
if (opts_optimizationcount[itr]) {
con_out("%s: %u\n", opts_opt_list[itr].name, (unsigned int)opts_optimizationcount[itr]);