X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ftepp.c;h=fbe6f9670d0feb404f11deb00f64f555c95b0652;hp=f0c34e47c2435015b37386b07bf03fb545abd996;hb=f1a662a4220b21400133dd984229f59a28b457fd;hpb=4c2e5d7ebf200b32711b6b6a1d4fd94287fc2394 diff --git a/ftepp.c b/ftepp.c index f0c34e4..fbe6f96 100644 --- a/ftepp.c +++ b/ftepp.c @@ -1,6 +1,7 @@ /* * Copyright (C) 2012 * Wolfgang Bumiller + * 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 @@ -55,7 +56,6 @@ typedef struct { typedef struct { lex_file *lex; int token; - bool newline; unsigned int errors; bool output_on; @@ -63,6 +63,9 @@ typedef struct { ppmacro **macros; char *output_string; + + char *itemname; + char *includename; } ftepp_t; #define ftepp_tokval(f) ((f)->lex->tok.value) @@ -75,7 +78,7 @@ static void ftepp_errorat(ftepp_t *ftepp, lex_ctx ctx, const char *fmt, ...) ftepp->errors++; va_start(ap, fmt); - con_vprintmsg(LVL_ERROR, ctx.file, ctx.line, "error", fmt, ap); + con_cvprintmsg((void*)&ctx, LVL_ERROR, "error", fmt, ap); va_end(ap); } @@ -86,27 +89,19 @@ static void ftepp_error(ftepp_t *ftepp, const char *fmt, ...) ftepp->errors++; va_start(ap, fmt); - con_vprintmsg(LVL_ERROR, ftepp->lex->tok.ctx.file, ftepp->lex->tok.ctx.line, "error", fmt, ap); + con_cvprintmsg((void*)&ftepp->lex->tok.ctx, LVL_ERROR, "error", fmt, ap); va_end(ap); } static bool GMQCC_WARN ftepp_warn(ftepp_t *ftepp, int warntype, const char *fmt, ...) { + bool r; va_list ap; - int lvl = LVL_WARNING; - - if (!OPTS_WARN(warntype)) - return false; - - if (opts_werror) { - lvl = LVL_ERROR; - ftepp->errors++; - } va_start(ap, fmt); - con_vprintmsg(lvl, ftepp->lex->tok.ctx.file, ftepp->lex->tok.ctx.line, "error", fmt, ap); + r = vcompile_warning(ftepp->lex->tok.ctx, warntype, fmt, ap); va_end(ap); - return opts_werror; + return r; } static pptoken *pptoken_make(ftepp_t *ftepp) @@ -133,6 +128,8 @@ static void pptoken_delete(pptoken *self) static ppmacro *ppmacro_new(lex_ctx ctx, const char *name) { ppmacro *macro = (ppmacro*)mem_a(sizeof(ppmacro)); + + (void)ctx; memset(macro, 0, sizeof(*macro)); macro->name = util_strdup(name); return macro; @@ -166,6 +163,10 @@ static ftepp_t* ftepp_new() static void ftepp_delete(ftepp_t *self) { size_t i; + if (self->itemname) + mem_d(self->itemname); + if (self->includename) + vec_free(self->includename); for (i = 0; i < vec_size(self->macros); ++i) ppmacro_delete(self->macros[i]); vec_free(self->macros); @@ -302,6 +303,8 @@ static bool ftepp_define_body(ftepp_t *ftepp, ppmacro *macro) static bool ftepp_define(ftepp_t *ftepp) { ppmacro *macro; + size_t l = ftepp_ctx(ftepp).line; + (void)ftepp_next(ftepp); if (!ftepp_skipspace(ftepp)) return false; @@ -342,6 +345,9 @@ static bool ftepp_define(ftepp_t *ftepp) else { ppmacro_delete(macro); } + + for (; l < ftepp_ctx(ftepp).line; ++l) + ftepp_out(ftepp, "\n", true); return true; } @@ -646,7 +652,17 @@ cleanup: * parameter lists on macros are errors * No mathematical calculations are executed */ -static bool ftepp_if_expr(ftepp_t *ftepp, bool *out) +static bool ftepp_if_expr(ftepp_t *ftepp, bool *out, double *value_out); +static bool ftepp_if_op(ftepp_t *ftepp) +{ + ftepp->lex->flags.noops = false; + ftepp_next(ftepp); + if (!ftepp_skipspace(ftepp)) + return false; + ftepp->lex->flags.noops = true; + return true; +} +static bool ftepp_if_value(ftepp_t *ftepp, bool *out, double *value_out) { ppmacro *macro; bool wasnot = false; @@ -698,13 +714,16 @@ static bool ftepp_if_expr(ftepp_t *ftepp, bool *out) macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp)); if (!macro || !vec_size(macro->output)) { *out = false; + *value_out = 0; } else { /* This does not expand recursively! */ switch (macro->output[0]->token) { case TOKEN_INTCONST: - *out = !!(macro->output[0]->constval.f); + *value_out = macro->output[0]->constval.i; + *out = !!(macro->output[0]->constval.i); break; case TOKEN_FLOATCONST: + *value_out = macro->output[0]->constval.f; *out = !!(macro->output[0]->constval.f); break; default: @@ -717,15 +736,17 @@ static bool ftepp_if_expr(ftepp_t *ftepp, bool *out) *out = false; break; case TOKEN_INTCONST: + *value_out = ftepp->lex->tok.constval.i; *out = !!(ftepp->lex->tok.constval.i); break; case TOKEN_FLOATCONST: + *value_out = ftepp->lex->tok.constval.f; *out = !!(ftepp->lex->tok.constval.f); break; case '(': ftepp_next(ftepp); - if (!ftepp_if_expr(ftepp, out)) + if (!ftepp_if_expr(ftepp, out, value_out)) return false; if (ftepp->token != ')') { ftepp_error(ftepp, "expected closing paren in #if expression"); @@ -734,38 +755,89 @@ static bool ftepp_if_expr(ftepp_t *ftepp, bool *out) break; default: - ftepp_error(ftepp, "junk in #if"); + ftepp_error(ftepp, "junk in #if: `%s` ...", ftepp_tokval(ftepp)); return false; } - if (wasnot) + if (wasnot) { *out = !*out; + *value_out = (*out ? 1 : 0); + } + return true; +} - ftepp->lex->flags.noops = false; - ftepp_next(ftepp); - if (!ftepp_skipspace(ftepp)) +/* +static bool ftepp_if_nextvalue(ftepp_t *ftepp, bool *out, double *value_out) +{ + if (!ftepp_next(ftepp)) return false; - ftepp->lex->flags.noops = true; + return ftepp_if_value(ftepp, out, value_out); +} +*/ - if (ftepp->token == ')') - return true; +static bool ftepp_if_expr(ftepp_t *ftepp, bool *out, double *value_out) +{ + if (!ftepp_if_value(ftepp, out, value_out)) + return false; - if (ftepp->token != TOKEN_OPERATOR) + if (!ftepp_if_op(ftepp)) + return false; + + if (ftepp->token == ')' || ftepp->token != TOKEN_OPERATOR) return true; + /* FTEQCC is all right-associative and no precedence here */ if (!strcmp(ftepp_tokval(ftepp), "&&") || !strcmp(ftepp_tokval(ftepp), "||")) { bool next = false; char opc = ftepp_tokval(ftepp)[0]; + double nextvalue; - ftepp_next(ftepp); - if (!ftepp_if_expr(ftepp, &next)) + (void)nextvalue; + if (!ftepp_next(ftepp)) + return false; + if (!ftepp_if_expr(ftepp, &next, &nextvalue)) return false; if (opc == '&') *out = *out && next; else *out = *out || next; + + *value_out = (*out ? 1 : 0); + return true; + } + else if (!strcmp(ftepp_tokval(ftepp), "==") || + !strcmp(ftepp_tokval(ftepp), "!=") || + !strcmp(ftepp_tokval(ftepp), ">=") || + !strcmp(ftepp_tokval(ftepp), "<=") || + !strcmp(ftepp_tokval(ftepp), ">") || + !strcmp(ftepp_tokval(ftepp), "<")) + { + bool next = false; + const char opc0 = ftepp_tokval(ftepp)[0]; + const char opc1 = ftepp_tokval(ftepp)[1]; + double other; + + if (!ftepp_next(ftepp)) + return false; + if (!ftepp_if_expr(ftepp, &next, &other)) + return false; + + if (opc0 == '=') + *out = (*value_out == other); + else if (opc0 == '!') + *out = (*value_out != other); + else if (opc0 == '>') { + if (opc1 == '=') *out = (*value_out >= other); + else *out = (*value_out > other); + } + else if (opc0 == '<') { + if (opc1 == '=') *out = (*value_out <= other); + else *out = (*value_out < other); + } + *value_out = (*out ? 1 : 0); + return true; } else { @@ -777,6 +849,7 @@ static bool ftepp_if_expr(ftepp_t *ftepp, bool *out) static bool ftepp_if(ftepp_t *ftepp, ppcondition *cond) { bool result = false; + double dummy = 0; memset(cond, 0, sizeof(*cond)); (void)ftepp_next(ftepp); @@ -788,7 +861,7 @@ static bool ftepp_if(ftepp_t *ftepp, ppcondition *cond) return false; } - if (!ftepp_if_expr(ftepp, &result)) + if (!ftepp_if_expr(ftepp, &result, &dummy)) return false; cond->on = result; @@ -864,6 +937,154 @@ static bool ftepp_undef(ftepp_t *ftepp) return true; } +/* Special unescape-string function which skips a leading quote + * and stops at a quote, not just at \0 + */ +static void unescape(const char *str, char *out) { + ++str; + while (*str && *str != '"') { + if (*str == '\\') { + ++str; + switch (*str) { + case '\\': *out++ = *str; break; + case '"': *out++ = *str; break; + case 'a': *out++ = '\a'; break; + case 'b': *out++ = '\b'; break; + case 'r': *out++ = '\r'; break; + case 'n': *out++ = '\n'; break; + case 't': *out++ = '\t'; break; + case 'f': *out++ = '\f'; break; + case 'v': *out++ = '\v'; break; + default: + *out++ = '\\'; + *out++ = *str; + break; + } + ++str; + continue; + } + + *out++ = *str++; + } + *out = 0; +} + +static char *ftepp_include_find_path(const char *file, const char *pathfile) +{ + FILE *fp; + char *filename = NULL; + const char *last_slash; + size_t len; + + if (!pathfile) + return NULL; + + last_slash = strrchr(pathfile, '/'); + + if (last_slash) { + len = last_slash - pathfile; + memcpy(vec_add(filename, len), pathfile, len); + vec_push(filename, '/'); + } + + len = strlen(file); + memcpy(vec_add(filename, len+1), file, len); + vec_last(filename) = 0; + + fp = util_fopen(filename, "rb"); + if (fp) { + fclose(fp); + return filename; + } + vec_free(filename); + return NULL; +} + +static char *ftepp_include_find(ftepp_t *ftepp, const char *file) +{ + char *filename = NULL; + + filename = ftepp_include_find_path(file, ftepp->includename); + if (!filename) + filename = ftepp_include_find_path(file, ftepp->itemname); + return filename; +} + +/** + * Include a file. + * FIXME: do we need/want a -I option? + * FIXME: what about when dealing with files in subdirectories coming from a progs.src? + */ +static bool ftepp_include(ftepp_t *ftepp) +{ + lex_file *old_lexer = ftepp->lex; + lex_file *inlex; + lex_ctx ctx; + char lineno[128]; + char *filename; + char *old_includename; + + (void)ftepp_next(ftepp); + if (!ftepp_skipspace(ftepp)) + return false; + + if (ftepp->token != TOKEN_STRINGCONST) { + ftepp_error(ftepp, "expected filename to include"); + return false; + } + + ctx = ftepp_ctx(ftepp); + + unescape(ftepp_tokval(ftepp), ftepp_tokval(ftepp)); + + ftepp_out(ftepp, "\n#pragma file(", false); + ftepp_out(ftepp, ftepp_tokval(ftepp), false); + ftepp_out(ftepp, ")\n#pragma line(1)\n", false); + + filename = ftepp_include_find(ftepp, ftepp_tokval(ftepp)); + if (!filename) { + ftepp_error(ftepp, "failed to open include file `%s`", ftepp_tokval(ftepp)); + return false; + } + inlex = lex_open(filename); + if (!inlex) { + ftepp_error(ftepp, "open failed on include file `%s`", filename); + vec_free(filename); + return false; + } + ftepp->lex = inlex; + old_includename = ftepp->includename; + ftepp->includename = filename; + if (!ftepp_preprocess(ftepp)) { + vec_free(ftepp->includename); + ftepp->includename = old_includename; + lex_close(ftepp->lex); + ftepp->lex = old_lexer; + return false; + } + vec_free(ftepp->includename); + ftepp->includename = old_includename; + lex_close(ftepp->lex); + ftepp->lex = old_lexer; + + ftepp_out(ftepp, "\n#pragma file(", false); + ftepp_out(ftepp, ctx.file, false); + snprintf(lineno, sizeof(lineno), ")\n#pragma line(%lu)\n", (unsigned long)(ctx.line+1)); + ftepp_out(ftepp, lineno, false); + + /* skip the line */ + (void)ftepp_next(ftepp); + if (!ftepp_skipspace(ftepp)) + return false; + if (ftepp->token != TOKEN_EOL) { + ftepp_error(ftepp, "stray tokens after #include"); + return false; + } + (void)ftepp_next(ftepp); + + return true; +} + /* Basic structure handlers */ static bool ftepp_else_allowed(ftepp_t *ftepp) { @@ -977,11 +1198,23 @@ static bool ftepp_hash(ftepp_t *ftepp) ftepp_update_output_condition(ftepp); break; } + else if (!strcmp(ftepp_tokval(ftepp), "include")) { + return ftepp_include(ftepp); + } + else if (!strcmp(ftepp_tokval(ftepp), "pragma")) { + ftepp_out(ftepp, "#", false); + break; + } else { - ftepp_error(ftepp, "unrecognized preprocessor directive: `%s`", ftepp_tokval(ftepp)); - return false; + if (ftepp->output_on) { + ftepp_error(ftepp, "unrecognized preprocessor directive: `%s`", ftepp_tokval(ftepp)); + return false; + } else { + ftepp_next(ftepp); + break; + } } - break; + /* break; never reached */ default: ftepp_error(ftepp, "unexpected preprocessor token: `%s`", ftepp_tokval(ftepp)); return false; @@ -1018,18 +1251,17 @@ static bool ftepp_preprocess(ftepp_t *ftepp) if (ftepp->token >= TOKEN_EOF) break; #if 0 - ftepp->newline = newline; - newline = false; -#else - /* For the sake of FTE compatibility... FU, really */ - ftepp->newline = newline = true; + newline = true; #endif switch (ftepp->token) { case TOKEN_KEYWORD: case TOKEN_IDENT: case TOKEN_TYPENAME: - macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp)); + if (ftepp->output_on) + macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp)); + else + macro = NULL; if (!macro) { ftepp_out(ftepp, ftepp_tokval(ftepp), false); ftepp_next(ftepp); @@ -1039,7 +1271,7 @@ static bool ftepp_preprocess(ftepp_t *ftepp) ftepp->token = TOKEN_ERROR; break; case '#': - if (!ftepp->newline) { + if (!newline) { ftepp_out(ftepp, ftepp_tokval(ftepp), false); ftepp_next(ftepp); break; @@ -1059,15 +1291,24 @@ static bool ftepp_preprocess(ftepp_t *ftepp) ftepp_out(ftepp, "\n", true); ftepp_next(ftepp); break; + case TOKEN_WHITE: + /* same as default but don't set newline=false */ + ftepp_out(ftepp, ftepp_tokval(ftepp), false); + ftepp_next(ftepp); + break; default: + newline = false; ftepp_out(ftepp, ftepp_tokval(ftepp), false); ftepp_next(ftepp); break; } } while (!ftepp->errors && ftepp->token < TOKEN_EOF); - newline = ftepp->token == TOKEN_EOF; - return newline; + /* force a 0 at the end but don't count it as added to the output */ + vec_push(ftepp->output_string, 0); + vec_shrinkby(ftepp->output_string, 1); + + return (ftepp->token == TOKEN_EOF); } /* Like in parser.c - files keep the previous state so we have one global @@ -1078,48 +1319,118 @@ static ftepp_t *ftepp; static bool ftepp_preprocess_done() { bool retval = true; - lex_close(ftepp->lex); - ftepp->lex = NULL; if (vec_size(ftepp->conditions)) { if (ftepp_warn(ftepp, WARN_MULTIFILE_IF, "#if spanning multiple files, is this intended?")) retval = false; } + lex_close(ftepp->lex); + ftepp->lex = NULL; + if (ftepp->itemname) { + mem_d(ftepp->itemname); + ftepp->itemname = NULL; + } return retval; } bool ftepp_preprocess_file(const char *filename) { ftepp->lex = lex_open(filename); + ftepp->itemname = util_strdup(filename); if (!ftepp->lex) { con_out("failed to open file \"%s\"\n", filename); return false; } - if (!ftepp_preprocess(ftepp)) { - ftepp_delete(ftepp); + if (!ftepp_preprocess(ftepp)) return false; - } return ftepp_preprocess_done(); } bool ftepp_preprocess_string(const char *name, const char *str) { - ftepp_t *ftepp = ftepp_new(); ftepp->lex = lex_open_string(str, strlen(str), name); + ftepp->itemname = util_strdup(name); if (!ftepp->lex) { con_out("failed to create lexer for string \"%s\"\n", name); return false; } - if (!ftepp_preprocess(ftepp)) { - ftepp_delete(ftepp); + if (!ftepp_preprocess(ftepp)) return false; - } return ftepp_preprocess_done(); } + +void ftepp_add_macro(const char *name, const char *value) { + char *create = NULL; + + /* use saner path for empty macros */ + if (!value) { + ftepp_add_define("__builtin__", name); + return; + } + + vec_upload(create, "#define ", 8); + vec_upload(create, name, strlen(name)); + vec_push (create, ' '); + vec_upload(create, value, strlen(value)); + vec_push (create, 0); + + ftepp_preprocess_string("__builtin__", create); + vec_free (create); +} + bool ftepp_init() { + char minor[32]; + char major[32]; + ftepp = ftepp_new(); - return !!ftepp; + if (!ftepp) + return false; + + memset(minor, 0, sizeof(minor)); + memset(major, 0, sizeof(major)); + + /* set the right macro based on the selected standard */ + ftepp_add_define(NULL, "GMQCC"); + if (opts.standard == COMPILER_FTEQCC) { + ftepp_add_define(NULL, "__STD_FTEQCC__"); + /* 1.00 */ + major[0] = '"'; + major[1] = '1'; + major[2] = '"'; + + minor[0] = '"'; + minor[1] = '0'; + minor[2] = '"'; + } else if (opts.standard == COMPILER_GMQCC) { + ftepp_add_define(NULL, "__STD_GMQCC__"); + sprintf(major, "\"%d\"", GMQCC_VERSION_MAJOR); + sprintf(minor, "\"%d\"", GMQCC_VERSION_MINOR); + } else if (opts.standard == COMPILER_QCC) { + ftepp_add_define(NULL, "__STD_QCC__"); + /* 1.0 */ + major[0] = '"'; + major[1] = '1'; + major[2] = '"'; + + minor[0] = '"'; + minor[1] = '0'; + minor[2] = '"'; + } + + ftepp_add_macro("__STD_VERSION_MINOR__", minor); + ftepp_add_macro("__STD_VERSION_MAJOR__", major); + + return true; +} + +void ftepp_add_define(const char *source, const char *name) +{ + ppmacro *macro; + lex_ctx ctx = { "__builtin__", 0 }; + ctx.file = source; + macro = ppmacro_new(ctx, name); + vec_push(ftepp->macros, macro); } const char *ftepp_get()