code.o \
ast.o \
ir.o \
- error.o
+ error.o \
+ con.o
OBJ_A = test/ast-test.o
OBJ_I = test/ir-test.o
OBJ_C = main.o lexer.o parser.o
--- /dev/null
+/*
+ * Copyright (C) 2012
+ * Dale Weiler
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include "gmqcc.h"
+
+/*
+ * isatty/STDERR_FILENO/STDOUT_FILNO
+ * + some other things likewise.
+ */
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+#define GMQCC_IS_STDOUT(X) ((X) == stdout)
+#define GMQCC_IS_STDERR(X) ((X) == stderr)
+#define GMQCC_IS_DEFINE(X) (GMQCC_IS_STDERR(X) || GMQCC_IS_STDOUT(X))
+
+typedef struct {
+ FILE *handle_err;
+ FILE *handle_out;
+
+ int color_err;
+ int color_out;
+} con_t;
+
+/*
+ * Doing colored output on windows is fucking stupid. The linux way is
+ * the real way. So we emulate it on windows :)
+ */
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+/*
+ * Windows doesn't have constants for FILENO, sadly but the docs tell
+ * use the constant values.
+ */
+#undef STDERR_FILENO
+#undef STDOUT_FILENO
+#define STDERR_FILENO 2
+#define STDOUT_FILENO 1
+
+/*
+ * Windows and it's posix underscore bullshit. We simply fix this
+ * with yay, another macro :P
+ */
+#define isatty _isatty
+
+enum {
+ RESET = 0,
+ BOLD = 1,
+ BLACK = 30,
+ RED,
+ GREEN,
+ YELLOW,
+ BLUE,
+ MAGENTA,
+ CYAN,
+ GRAY,
+ WHITE
+};
+
+enum {
+ WBLACK,
+ WBLUE,
+ WGREEN = 2,
+ WRED = 4,
+ WINTENSE = 8,
+ WCYAN = WBLUE | WGREEN,
+ WMAGENTA = WBLUE | WRED,
+ WYELLOW = WGREEN | WRED,
+ WWHITE = WBLUE | WGREEN | WRED
+}
+
+static const ansi2win[] = {
+ WBLACK,
+ WRED,
+ WGREEN,
+ WYELLOW,
+ WBLUE,
+ WMAGENTA,
+ WCYAN,
+ WWHITE
+};
+
+static void win_fputs(char *str, FILE *f) {
+ /* state for translate */
+ int acolor;
+ int wcolor;
+ int icolor;
+
+ int state;
+ int place;
+
+ /* attributes */
+ int intense = -1;
+ int colors[] = {-1, -1 };
+ int colorpos = 1;
+
+ CONSOLE_SCREEN_BUFFER_INFO cinfo;
+ GetConsoleScreenBufferInfo(
+ (h == stdout) ?
+ GetStdHandle(STD_OUTPUT_HANDLE) :
+ GetStdHandle(STD_ERROR_HANDLE), &cinfo
+ );
+ icolor = cinfo.wAttributes;
+
+ while (*str) {
+ if (*str == '\e')
+ state = '\e';
+ else if (state == '\e' && *str == '[')
+ state = '[';
+ else if (state == '[') {
+ if (*str != 'm') {
+ colors[colorpos] = *str;
+ colorpos--;
+ } else {
+ int find;
+ int mult;
+ for (find = colorpos + 1, acolor = 0, mult = 1; find < 2; find++) {
+ acolor += (colors[find] - 48) * mult;
+ mult *= 10;
+ }
+
+ /* convert to windows color */
+ if (acolor == BOLD)
+ intense = WINTENSE;
+ else if (acolor == RESET) {
+ intense = WBLACK;
+ wcolor = icolor;
+ }
+ else if (BLACK < acolor && acolor <= WHITE)
+ wcolor = ansi2win[acolor - 30];
+ else if (acolor == 90) {
+ /* special gray really white man */
+ wcolor = WWHITE;
+ intense = WBLACK;
+ }
+
+ SetConsoleTextattribute(
+ (h == stdout) ?
+ GetStdHandle(STD_OUTPUT_HANDLE) :
+ GetStdHandle(STD_ERROR_HANDLE),
+
+ wcolor | intense | (icolor & 0xF0)
+ );
+ colorpos = 1;
+ state = -1;
+ }
+ } else {
+ fputc(*str, h);
+ }
+ }
+ /* restore */
+ SetConsoleTextAttribute(
+ (h == stdout) ?
+ GetStdHandle(STD_OUTPUT_HANDLE) :
+ GetStdHandle(STD_ERROR_HANDLE),
+ icolor
+ );
+}
+#endif
+
+/*
+ * We use standard files as default. These can be changed at any time
+ * with con_change(F, F)
+ */
+static con_t console;
+
+/*
+ * Enables color on output if supported.
+ * NOTE: The support for checking colors is NULL. On windows this will
+ * always work, on *nix it depends if the term has colors.
+ *
+ * NOTE: This prevents colored output to piped stdout/err via isatty
+ * checks.
+ */
+static void con_enablecolor() {
+ if (console.handle_err == stderr || console.handle_err == stdout)
+ console.color_err = !!(isatty(STDERR_FILENO));
+ if (console.handle_out == stderr || console.handle_out == stdout)
+ console.color_out = !!(isatty(STDOUT_FILENO));
+}
+
+/*
+ * Does a write to the handle with the format string and list of
+ * arguments. This colorizes for windows as well via translate
+ * step.
+ */
+static int con_write(FILE *handle, const char *fmt, va_list va) {
+ int ln;
+ #ifndef _WIN32
+ ln = vfprintf(handle, fmt, va);
+ #else
+ {
+ char *data = NULL;
+ ln = _vscprintf(fmt, va);
+ data = malloc(ln + 1);
+ data[ln] = 0;
+ vsprintf(data, fmt, va);
+ if (GMQCC_IS_DEFINE(handle))
+ ln = win_fputs(data, handle);
+ else
+ ln = fputs(data, handle);
+ free(data);
+ }
+ #endif
+ return ln;
+}
+
+/**********************************************************************
+ * EXPOSED INTERFACE BEGINS
+ *********************************************************************/
+
+void con_close() {
+ if (!GMQCC_IS_DEFINE(console.handle_err))
+ fclose(console.handle_err);
+ if (!GMQCC_IS_DEFINE(console.handle_out))
+ fclose(console.handle_out);
+}
+
+void con_color(int state) {
+ if (state)
+ con_enablecolor();
+ else {
+ console.color_err = 0;
+ console.color_out = 0;
+ }
+}
+
+void con_init() {
+ console.handle_err = stderr;
+ console.handle_out = stdout;
+ con_enablecolor();
+}
+
+void con_reset() {
+ con_close();
+ con_init ();
+}
+
+/*
+ * This is clever, say you want to change the console to use two
+ * files for out/err. You pass in two strings, it will properly
+ * close the existing handles (if they're not std* handles) and
+ * open them. Now say you want TO use stdout and stderr, this
+ * allows you to do that so long as you cast them to (char*).
+ * Say you need stdout for out, but want a file for error, you can
+ * do this too, just cast the stdout for (char*) and stick to a
+ * string for the error file.
+ */
+int con_change(const char *out, const char *err) {
+ con_close();
+
+ if (GMQCC_IS_DEFINE((FILE*)out)) {
+ console.handle_out = (((FILE*)err) == stdout) ? stdout : stderr;
+ con_enablecolor();
+ } else if (!(console.handle_out = fopen(out, "w"))) return 0;
+
+ if (GMQCC_IS_DEFINE((FILE*)err)) {
+ console.handle_err = (((FILE*)err) == stdout) ? stdout : stderr;
+ con_enablecolor();
+ } else if (!(console.handle_err = fopen(err, "w"))) return 0;
+
+ return 1;
+}
+
+int con_verr(const char *fmt, va_list va) {
+ return con_write(console.handle_err, fmt, va);
+}
+int con_vout(const char *fmt, va_list va) {
+ return con_write(console.handle_out, fmt, va);
+}
+
+int con_err(const char *fmt, ...) {
+ va_list va;
+ int ln = 0;
+ va_start(va, fmt);
+ con_verr(fmt, va);
+ va_end (va);
+ return ln;
+}
+int con_out(const char *fmt, ...) {
+ va_list va;
+ int ln = 0;
+ va_start(va, fmt);
+ con_vout(fmt, va);
+ va_end (va);
+ return ln;
+}
uint32_t code_cachedstring(const char *string);
qcint code_alloc_field (size_t qcsize);
+/*===================================================================*/
+/*============================ con.c ================================*/
+/*===================================================================*/
+void con_close();
+void con_color(int state);
+void con_init ();
+void con_reset();
+int con_change(const char *out, const char *err);
+int con_verr (const char *fmt, va_list va);
+int con_vout (const char *fmt, va_list va);
+int con_err (const char *fmt, ...);
+int con_out (const char *fmt, ...);
+
/*===================================================================*/
/*========================= assembler.c =============================*/
/*===================================================================*/
{ "END" , 0, 3 } /* virtual assembler instruction */
};
-
-void asm_init (const char *, FILE **);
-void asm_close(FILE *);
-void asm_parse(FILE *);
/*===================================================================*/
/*============================= ast.c ===============================*/
/*===================================================================*/
static const char *app_name;
static int usage() {
- printf("usage: %s [options] [files...]", app_name);
- printf("options:\n"
+ con_out("usage: %s [options] [files...]", app_name);
+ con_out("options:\n"
" -h, --help show this help message\n"
" -debug turns on compiler debug messages\n"
" -memchk turns on compiler memory leak check\n");
- printf(" -o, --output=file output file, defaults to progs.dat\n"
+ con_out(" -o, --output=file output file, defaults to progs.dat\n"
" -a filename add an asm file to be assembled\n"
" -s filename add a progs.src file to be used\n");
- printf(" -E stop after preprocessing\n");
- printf(" -f<flag> enable a flag\n"
+ con_out(" -E stop after preprocessing\n");
+ con_out(" -f<flag> enable a flag\n"
" -fno-<flag> disable a flag\n"
" -std standard select one of the following standards\n"
" -std=qcc original QuakeC\n"
" -std=fteqcc fteqcc QuakeC\n"
" -std=gmqcc this compiler (default)\n");
- printf(" -W<warning> enable a warning\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");
- printf(" -force-crc=num force a specific checksum into the header\n");
- printf("\n");
- printf("flags:\n"
+ con_out(" -force-crc=num force a specific checksum into the header\n");
+ con_out("\n");
+ con_out("flags:\n"
" -fadjust-vector-fields\n"
" when assigning a vector field, its _y and _z fields also get assigned\n"
);
else if (!strcmp(argarg, "qccx"))
opts_standard = COMPILER_QCCX;
else {
- printf("Unknown standard: %s\n", argarg);
+ con_out("Unknown standard: %s\n", argarg);
return false;
}
continue;
case 'f':
util_strtocmd(argv[0]+2, argv[0]+2, strlen(argv[0]+2)+1);
if (!strcmp(argv[0]+2, "HELP")) {
- printf("Possible flags:\n");
+ con_out("Possible flags:\n");
for (itr = 0; itr < COUNT_FLAGS; ++itr) {
util_strtononcmd(opts_flag_list[itr].name, buffer, sizeof(buffer));
- printf(" -f%s\n", buffer);
+ con_out(" -f%s\n", buffer);
}
exit(0);
}
else if (!strncmp(argv[0]+2, "NO_", 3)) {
if (!options_setflag(argv[0]+5, false)) {
- printf("unknown flag: %s\n", argv[0]+2);
+ con_out("unknown flag: %s\n", argv[0]+2);
return false;
}
}
else if (!options_setflag(argv[0]+2, true)) {
- printf("unknown flag: %s\n", argv[0]+2);
+ con_out("unknown flag: %s\n", argv[0]+2);
return false;
}
break;
case 'W':
util_strtocmd(argv[0]+2, argv[0]+2, strlen(argv[0]+2)+1);
if (!strcmp(argv[0]+2, "HELP")) {
- printf("Possible warnings:\n");
+ con_out("Possible warnings:\n");
for (itr = 0; itr < COUNT_WARNINGS; ++itr) {
util_strtononcmd(opts_warn_list[itr].name, buffer, sizeof(buffer));
- printf(" -W%s\n", buffer);
+ con_out(" -W%s\n", buffer);
}
exit(0);
}
}
if (!strncmp(argv[0]+2, "NO_", 3)) {
if (!options_setwarn(argv[0]+5, false)) {
- printf("unknown warning: %s\n", argv[0]+2);
+ con_out("unknown warning: %s\n", argv[0]+2);
return false;
}
}
else if (!options_setwarn(argv[0]+2, true)) {
- printf("unknown warning: %s\n", argv[0]+2);
+ con_out("unknown warning: %s\n", argv[0]+2);
return false;
}
break;
case 'O':
if (!options_witharg(&argc, &argv, &argarg)) {
- printf("option -O requires a numerical argument\n");
+ con_out("option -O requires a numerical argument\n");
return false;
}
opts_O = atoi(argarg);
case 'o':
if (!options_witharg(&argc, &argv, &argarg)) {
- printf("option -o requires an argument: the output file name\n");
+ con_out("option -o requires an argument: the output file name\n");
return false;
}
opts_output = argarg;
case 's':
item.type = argv[0][1] == 'a' ? TYPE_ASM : TYPE_SRC;
if (!options_witharg(&argc, &argv, &argarg)) {
- printf("option -a requires a filename %s\n",
+ con_out("option -a requires a filename %s\n",
(argv[0][1] == 'a' ? "containing QC-asm" : "containing a progs.src formatted list"));
return false;
}
opts_output = argarg;
opts_output_wasset = true;
} else {
- printf("Unknown parameter: %s\n", argv[0]);
+ con_out("Unknown parameter: %s\n", argv[0]);
return false;
}
}
break;
default:
- printf("Unknown parameter: %s\n", argv[0]);
+ con_out("Unknown parameter: %s\n", argv[0]);
return false;
}
}
bool opts_output_free = false;
app_name = argv[0];
+ con_init();
/* default options / warn flags */
options_set(opts_warn, WARN_UNKNOWN_CONTROL_SEQUENCE, true);
if (opts_dump) {
for (itr = 0; itr < COUNT_FLAGS; ++itr) {
- printf("Flag %s = %i\n", opts_flag_list[itr].name, OPTS_FLAG(itr));
+ con_out("Flag %s = %i\n", opts_flag_list[itr].name, OPTS_FLAG(itr));
}
for (itr = 0; itr < COUNT_WARNINGS; ++itr) {
- printf("Warning %s = %i\n", opts_warn_list[itr].name, OPTS_WARN(itr));
+ con_out("Warning %s = %i\n", opts_warn_list[itr].name, OPTS_WARN(itr));
}
- printf("output = %s\n", opts_output);
- printf("optimization level = %i\n", (int)opts_O);
- printf("standard = %i\n", opts_standard);
+ con_out("output = %s\n", opts_output);
+ con_out("optimization level = %i\n", (int)opts_O);
+ con_out("standard = %i\n", opts_standard);
}
if (!parser_init()) {
- printf("failed to initialize parser\n");
+ con_out("failed to initialize parser\n");
retval = 1;
goto cleanup;
}
util_debug("COM", "starting ...\n");
if (items_elements) {
- printf("Mode: manual\n");
- printf("There are %lu items to compile:\n", (unsigned long)items_elements);
+ con_out("Mode: manual\n");
+ con_out("There are %lu items to compile:\n", (unsigned long)items_elements);
for (itr = 0; itr < items_elements; ++itr) {
- #ifndef JS
- printf(" item: %s (%s)\n",
+ con_out(" item: %s (%s)\n",
items_data[itr].filename,
( (items_data[itr].type == TYPE_QC ? "qc" :
(items_data[itr].type == TYPE_ASM ? "asm" :
(items_data[itr].type == TYPE_SRC ? "progs.src" :
("unknown"))))));
- #endif
- #ifdef JS
- if (!parser_compile_string("js.qc", items_data[itr].filename))
- #else
- if (!parser_compile_file(items_data[itr].filename))
- #endif
+ if (!parser_compile_file(items_data[itr].filename))
{
retval = 1;
goto cleanup;
char *line;
size_t linelen = 0;
- printf("Mode: progs.src\n");
+ con_out("Mode: progs.src\n");
src = util_fopen("progs.src", "rb");
if (!src) {
- printf("failed to open `progs.src` for reading\n");
+ con_out("failed to open `progs.src` for reading\n");
retval = 1;
goto cleanup;
}
line = NULL;
if (!progs_nextline(&line, &linelen, src) || !line[0]) {
- printf("illformatted progs.src file: expected output filename in first line\n");
+ con_out("illformatted progs.src file: expected output filename in first line\n");
retval = 1;
goto srcdone;
}
while (progs_nextline(&line, &linelen, src)) {
if (!line[0] || (line[0] == '/' && line[1] == '/'))
continue;
- printf(" src: %s\n", line);
+ con_out(" src: %s\n", line);
if (!parser_compile_file(line)) {
retval = 1;
goto srcdone;
op = &operators[sy->ops[sy->ops_count-1].etype - 1];
ctx = sy->ops[sy->ops_count-1].ctx;
- DEBUGSHUNTDO(printf("apply %s\n", op->op));
+ DEBUGSHUNTDO(con_out("apply %s\n", op->op));
if (sy->out_count < op->operands) {
parseerror(parser, "internal error: not enough operands: %i (operator %s (%i))", sy->out_count,
return false;
}
if (opts_standard == COMPILER_GMQCC)
- printf("TODO: early out logic\n");
+ con_out("TODO: early out logic\n");
if (CanConstFold(exprs[0], exprs[1]))
out = (ast_expression*)parser_const_float(parser,
(generated_op == INSTR_OR ? (ConstF(0) || ConstF(1)) : (ConstF(0) && ConstF(1))));
return false;
}
- DEBUGSHUNTDO(printf("applied %s\n", op->op));
+ DEBUGSHUNTDO(con_out("applied %s\n", op->op));
sy->out[sy->out_count++] = syexp(ctx, out);
return true;
}
parseerror(parser, "out of memory");
goto onerr;
}
- DEBUGSHUNTDO(printf("push %s\n", parser_tokval(parser)));
+ DEBUGSHUNTDO(con_out("push %s\n", parser_tokval(parser)));
}
else if (parser->tok == TOKEN_FLOATCONST) {
ast_value *val;
parseerror(parser, "out of memory");
goto onerr;
}
- DEBUGSHUNTDO(printf("push %g\n", parser_token(parser)->constval.f));
+ DEBUGSHUNTDO(con_out("push %g\n", parser_token(parser)->constval.f));
}
else if (parser->tok == TOKEN_INTCONST) {
ast_value *val;
parseerror(parser, "out of memory");
goto onerr;
}
- DEBUGSHUNTDO(printf("push %i\n", parser_token(parser)->constval.i));
+ DEBUGSHUNTDO(con_out("push %i\n", parser_token(parser)->constval.i));
}
else if (parser->tok == TOKEN_STRINGCONST) {
ast_value *val;
parseerror(parser, "out of memory");
goto onerr;
}
- DEBUGSHUNTDO(printf("push string\n"));
+ DEBUGSHUNTDO(con_out("push string\n"));
}
else if (parser->tok == TOKEN_VECTORCONST) {
ast_value *val;
parseerror(parser, "out of memory");
goto onerr;
}
- DEBUGSHUNTDO(printf("push '%g %g %g'\n",
+ DEBUGSHUNTDO(con_out("push '%g %g %g'\n",
parser_token(parser)->constval.v.x,
parser_token(parser)->constval.v.y,
parser_token(parser)->constval.v.z));
}
else if (parser->tok == ')') {
if (wantop) {
- DEBUGSHUNTDO(printf("do[op] )\n"));
+ DEBUGSHUNTDO(con_out("do[op] )\n"));
--parens;
if (parens < 0)
break;
if (!parser_close_paren(parser, &sy, false))
goto onerr;
} else {
- DEBUGSHUNTDO(printf("do[nop] )\n"));
+ DEBUGSHUNTDO(con_out("do[nop] )\n"));
--parens;
if (parens < 0)
break;
if (op->id == opid1('(')) {
if (wantop) {
- DEBUGSHUNTDO(printf("push [op] (\n"));
+ DEBUGSHUNTDO(con_out("push [op] (\n"));
++parens;
/* we expected an operator, this is the function-call operator */
if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
parseerror(parser, "out of memory");
goto onerr;
}
- DEBUGSHUNTDO(printf("push [nop] (\n"));
+ DEBUGSHUNTDO(con_out("push [nop] (\n"));
}
wantop = false;
} else {
- DEBUGSHUNTDO(printf("push operator %s\n", op->op));
+ DEBUGSHUNTDO(con_out("push operator %s\n", op->op));
if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
goto onerr;
wantop = false;
expr = sy.out[0].out;
MEM_VECTOR_CLEAR(&sy, out);
MEM_VECTOR_CLEAR(&sy, ops);
- DEBUGSHUNTDO(printf("shunt done\n"));
+ DEBUGSHUNTDO(con_out("shunt done\n"));
return expr;
onerr:
{
parser->lex = lex_open(filename);
if (!parser->lex) {
- printf("failed to open file \"%s\"\n", filename);
+ con_out("failed to open file \"%s\"\n", filename);
return false;
}
return parser_compile();
{
parser->lex = lex_open_string(str, strlen(str), name);
if (!parser->lex) {
- printf("failed to create lexer for string \"%s\"\n", name);
+ con_out("failed to create lexer for string \"%s\"\n", name);
return false;
}
return parser_compile();
{
ir = ir_builder_new("gmqcc_out");
if (!ir) {
- printf("failed to allocate builder\n");
+ con_out("failed to allocate builder\n");
return false;
}
isconst = field->isconst;
field->isconst = false;
if (!ast_global_codegen((ast_value*)field, ir)) {
- printf("failed to generate field %s\n", field->name);
+ con_out("failed to generate field %s\n", field->name);
ir_builder_delete(ir);
return false;
}
}
}
if (!ast_global_codegen(asvalue, ir)) {
- printf("failed to generate global %s\n", parser->globals[i].name);
+ con_out("failed to generate global %s\n", parser->globals[i].name);
ir_builder_delete(ir);
return false;
}
}
for (i = 0; i < parser->imm_float_count; ++i) {
if (!ast_global_codegen(parser->imm_float[i], ir)) {
- printf("failed to generate global %s\n", parser->imm_float[i]->name);
+ con_out("failed to generate global %s\n", parser->imm_float[i]->name);
ir_builder_delete(ir);
return false;
}
}
for (i = 0; i < parser->imm_string_count; ++i) {
if (!ast_global_codegen(parser->imm_string[i], ir)) {
- printf("failed to generate global %s\n", parser->imm_string[i]->name);
+ con_out("failed to generate global %s\n", parser->imm_string[i]->name);
ir_builder_delete(ir);
return false;
}
}
for (i = 0; i < parser->imm_vector_count; ++i) {
if (!ast_global_codegen(parser->imm_vector[i], ir)) {
- printf("failed to generate global %s\n", parser->imm_vector[i]->name);
+ con_out("failed to generate global %s\n", parser->imm_vector[i]->name);
ir_builder_delete(ir);
return false;
}
}
for (i = 0; i < parser->functions_count; ++i) {
if (!ast_function_codegen(parser->functions[i], ir)) {
- printf("failed to generate function %s\n", parser->functions[i]->name);
+ con_out("failed to generate function %s\n", parser->functions[i]->name);
ir_builder_delete(ir);
return false;
}
if (!ir_function_finalize(parser->functions[i]->ir_func)) {
- printf("failed to finalize function %s\n", parser->functions[i]->name);
+ con_out("failed to finalize function %s\n", parser->functions[i]->name);
ir_builder_delete(ir);
return false;
}
if (retval) {
if (opts_dump)
- ir_builder_dump(ir, printf);
+ ir_builder_dump(ir, con_out);
generate_checksum(parser);
if (!ir_builder_generate(ir, output)) {
- printf("*** failed to generate output file\n");
+ con_out("*** failed to generate output file\n");
ir_builder_delete(ir);
return false;
}
return retval;
}
- printf("*** there were compile errors\n");
+ con_out("*** there were compile errors\n");
return false;
}
return;
va_start(va, ms);
- fprintf (stdout, "DEBUG: ");
- fputc ('[', stdout);
- fprintf(stdout, "%s", area);
- fputs ("] ", stdout);
- vfprintf(stdout, ms, va);
+ con_out ("[%s] ", area);
+ con_vout(ms, va);
va_end (va);
}
projects / xonotic / gmqcc.git / commitdiff