X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ftepp.c;h=ea686612cfd08156d65fe7326a29a205516779e6;hp=7969231299a00b2dd8f06bafa0d33e2c8f838bde;hb=861987e13efd3967037017f74152bcc1afbbe257;hpb=8bce855f0b78fe2509d1c6e588cb17691229079e diff --git a/ftepp.c b/ftepp.c index 7969231..ea68661 100644 --- a/ftepp.c +++ b/ftepp.c @@ -1,6 +1,7 @@ /* - * Copyright (C) 2012 + * Copyright (C) 2012, 2013 * 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 @@ -20,6 +21,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ +#include #include "gmqcc.h" #include "lexer.h" @@ -48,6 +50,7 @@ typedef struct { char **params; /* yes we need an extra flag since `#define FOO x` is not the same as `#define FOO() x` */ bool has_params; + bool variadic; pptoken **output; } ppmacro; @@ -55,7 +58,6 @@ typedef struct { typedef struct { lex_file *lex; int token; - bool newline; unsigned int errors; bool output_on; @@ -68,6 +70,110 @@ typedef struct { char *includename; } ftepp_t; +/* + * Implement the predef subsystem now. We can do this safely with the + * help of lexer contexts. + */ +static uint32_t ftepp_predef_countval = 0; +static uint32_t ftepp_predef_randval = 0; + +/* __DATE__ */ +char *ftepp_predef_date(lex_file *context) { + struct tm *itime; + time_t rtime; + char *value = mem_a(82); + /* 82 is enough for strftime but we also have " " in our string */ + + (void)context; + + /* get time */ + time (&rtime); + itime = localtime(&rtime); + + strftime(value, 82, "\"%b %d %Y\"", itime); + + return value; +} + +/* __TIME__ */ +char *ftepp_predef_time(lex_file *context) { + struct tm *itime; + time_t rtime; + char *value = mem_a(82); + /* 82 is enough for strftime but we also have " " in our string */ + + (void)context; + + /* get time */ + time (&rtime); + itime = localtime(&rtime); + + strftime(value, 82, "\"%X\"", itime); + + return value; +} + +/* __LINE__ */ +char *ftepp_predef_line(lex_file *context) { + char *value; + util_asprintf(&value, "%d", (int)context->line); + return value; +} +/* __FILE__ */ +char *ftepp_predef_file(lex_file *context) { + size_t length = strlen(context->name) + 3; /* two quotes and a terminator */ + char *value = (char*)mem_a(length); + memset (value, 0, length); + sprintf(value, "\"%s\"", context->name); + + return value; +} +/* __COUNTER_LAST__ */ +char *ftepp_predef_counterlast(lex_file *context) { + char *value; + util_asprintf(&value, "%u", ftepp_predef_countval); + + (void)context; + return value; +} +/* __COUNTER__ */ +char *ftepp_predef_counter(lex_file *context) { + char *value; + ftepp_predef_countval ++; + util_asprintf(&value, "%u", ftepp_predef_countval); + (void)context; + + return value; +} +/* __RANDOM__ */ +char *ftepp_predef_random(lex_file *context) { + char *value; + ftepp_predef_randval = (util_rand() % 0xFF) + 1; + util_asprintf(&value, "%u", ftepp_predef_randval); + + (void)context; + return value; +} +/* __RANDOM_LAST__ */ +char *ftepp_predef_randomlast(lex_file *context) { + char *value; + util_asprintf(&value, "%u", ftepp_predef_randval); + + (void)context; + return value; +} + +const ftepp_predef_t ftepp_predefs[FTEPP_PREDEF_COUNT] = { + { "__LINE__", &ftepp_predef_line }, + { "__FILE__", &ftepp_predef_file }, + { "__COUNTER__", &ftepp_predef_counter }, + { "__COUNTER_LAST__", &ftepp_predef_counterlast }, + { "__RANDOM__", &ftepp_predef_random }, + { "__RANDOM_LAST__", &ftepp_predef_randomlast }, + { "__DATE__", &ftepp_predef_date }, + { "__TIME__", &ftepp_predef_time } +}; + #define ftepp_tokval(f) ((f)->lex->tok.value) #define ftepp_ctx(f) ((f)->lex->tok.ctx) @@ -95,21 +201,13 @@ static void ftepp_error(ftepp_t *ftepp, const char *fmt, ...) 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_cvprintmsg((void*)&ftepp->lex->tok.ctx, lvl, "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) @@ -136,7 +234,7 @@ 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); @@ -168,9 +266,15 @@ static ftepp_t* ftepp_new() return ftepp; } +static void ftepp_flush_do(ftepp_t *self) +{ + vec_free(self->output_string); +} + static void ftepp_delete(ftepp_t *self) { size_t i; + ftepp_flush_do(self); if (self->itemname) mem_d(self->itemname); if (self->includename) @@ -225,7 +329,7 @@ static void ftepp_macro_delete(ftepp_t *ftepp, const char *name) } } -static inline int ftepp_next(ftepp_t *ftepp) +static GMQCC_INLINE int ftepp_next(ftepp_t *ftepp) { return (ftepp->token = lex_do(ftepp->lex)); } @@ -273,15 +377,22 @@ static bool ftepp_define_params(ftepp_t *ftepp, ppmacro *macro) case TOKEN_IDENT: case TOKEN_TYPENAME: case TOKEN_KEYWORD: + vec_push(macro->params, util_strdup(ftepp_tokval(ftepp))); + break; + case TOKEN_DOTS: + macro->variadic = true; break; default: ftepp_error(ftepp, "unexpected token in parameter list"); return false; } - vec_push(macro->params, util_strdup(ftepp_tokval(ftepp))); ftepp_next(ftepp); if (!ftepp_skipspace(ftepp)) return false; + if (macro->variadic && ftepp->token != ')') { + ftepp_error(ftepp, "cannot have parameters after the variadic parameters"); + return false; + } } while (ftepp->token == ','); if (ftepp->token != ')') { ftepp_error(ftepp, "expected closing paren after macro parameter list"); @@ -296,6 +407,8 @@ static bool ftepp_define_body(ftepp_t *ftepp, ppmacro *macro) { pptoken *ptok; while (ftepp->token != TOKEN_EOL && ftepp->token < TOKEN_EOF) { + if (macro->variadic && !strcmp(ftepp_tokval(ftepp), "__VA_ARGS__")) + ftepp->token = TOKEN_VA_ARGS; ptok = pptoken_make(ftepp); vec_push(macro->output, ptok); ftepp_next(ftepp); @@ -311,6 +424,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; @@ -351,6 +466,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; } @@ -502,18 +620,38 @@ static void ftepp_recursion_footer(ftepp_t *ftepp) ftepp_out(ftepp, "\n#pragma pop(line)\n", false); } +static void ftepp_param_out(ftepp_t *ftepp, macroparam *param) +{ + size_t i; + pptoken *out; + for (i = 0; i < vec_size(param->tokens); ++i) { + out = param->tokens[i]; + if (out->token == TOKEN_EOL) + ftepp_out(ftepp, "\n", false); + else + ftepp_out(ftepp, out->value, false); + } +} + static bool ftepp_preprocess(ftepp_t *ftepp); static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *params) { - char *old_string = ftepp->output_string; - lex_file *old_lexer = ftepp->lex; - bool retval = true; + char *old_string = ftepp->output_string; + lex_file *old_lexer = ftepp->lex; + size_t vararg_start = vec_size(macro->params); + bool retval = true; + size_t varargs; - size_t o, pi, pv; + size_t o, pi; lex_file *inlex; int nextok; + if (vararg_start < vec_size(params)) + varargs = vec_size(params) - vararg_start; + else + varargs = 0; + /* really ... */ if (!vec_size(macro->output)) return true; @@ -522,21 +660,28 @@ static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *param for (o = 0; o < vec_size(macro->output); ++o) { pptoken *out = macro->output[o]; switch (out->token) { + case TOKEN_VA_ARGS: + if (!macro->variadic) { + ftepp_error(ftepp, "internal preprocessor error: TOKEN_VA_ARGS in non-variadic macro"); + return false; + } + if (!varargs) + break; + pi = 0; + ftepp_param_out(ftepp, ¶ms[pi + vararg_start]); + for (++pi; pi < varargs; ++pi) { + ftepp_out(ftepp, ", ", false); + ftepp_param_out(ftepp, ¶ms[pi + vararg_start]); + } + break; case TOKEN_IDENT: case TOKEN_TYPENAME: case TOKEN_KEYWORD: if (!macro_params_find(macro, out->value, &pi)) { ftepp_out(ftepp, out->value, false); break; - } else { - for (pv = 0; pv < vec_size(params[pi].tokens); ++pv) { - out = params[pi].tokens[pv]; - if (out->token == TOKEN_EOL) - ftepp_out(ftepp, "\n", false); - else - ftepp_out(ftepp, out->value, false); - } - } + } else + ftepp_param_out(ftepp, ¶ms[pi]); break; case '#': if (o + 1 < vec_size(macro->output)) { @@ -578,13 +723,18 @@ static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *param goto cleanup; } ftepp->output_string = old_string; + inlex->line = ftepp->lex->line; + inlex->sline = ftepp->lex->sline; ftepp->lex = inlex; ftepp_recursion_header(ftepp); if (!ftepp_preprocess(ftepp)) { + vec_free(ftepp->lex->open_string); + old_string = ftepp->output_string; lex_close(ftepp->lex); retval = false; goto cleanup; } + vec_free(ftepp->lex->open_string); ftepp_recursion_footer(ftepp); old_string = ftepp->output_string; @@ -620,8 +770,11 @@ static bool ftepp_macro_call(ftepp_t *ftepp, ppmacro *macro) if (!ftepp_macro_call_params(ftepp, ¶ms)) return false; - if (vec_size(params) != vec_size(macro->params)) { - ftepp_error(ftepp, "macro %s expects %u paramteters, %u provided", macro->name, + if ( vec_size(params) < vec_size(macro->params) || + (vec_size(params) > vec_size(macro->params) && !macro->variadic) ) + { + ftepp_error(ftepp, "macro %s expects%s %u paramteters, %u provided", macro->name, + (macro->variadic ? " at least" : ""), (unsigned int)vec_size(macro->params), (unsigned int)vec_size(params)); retval = false; @@ -989,20 +1142,14 @@ static char *ftepp_include_find_path(const char *file, const char *pathfile) memcpy(vec_add(filename, len), pathfile, len); vec_push(filename, '/'); } - else { - len = strlen(pathfile); - memcpy(vec_add(filename, len), pathfile, len); - if (vec_last(filename) != '/') - vec_push(filename, '/'); - } len = strlen(file); memcpy(vec_add(filename, len+1), file, len); vec_last(filename) = 0; - fp = util_fopen(filename, "rb"); + fp = file_open(filename, "rb"); if (fp) { - fclose(fp); + file_close(fp); return filename; } vec_free(filename); @@ -1019,6 +1166,55 @@ static char *ftepp_include_find(ftepp_t *ftepp, const char *file) return filename; } +static bool ftepp_directive_warning(ftepp_t *ftepp) { + char *message = NULL; + + if (!ftepp_skipspace(ftepp)) + return false; + + /* handle the odd non string constant case so it works like C */ + if (ftepp->token != TOKEN_STRINGCONST) { + bool store = false; + vec_upload(message, "#warning", 8); + ftepp_next(ftepp); + while (ftepp->token != TOKEN_EOL) { + vec_upload(message, ftepp_tokval(ftepp), strlen(ftepp_tokval(ftepp))); + ftepp_next(ftepp); + } + vec_push(message, '\0'); + store = ftepp_warn(ftepp, WARN_CPP, message); + vec_free(message); + return store; + } + + unescape (ftepp_tokval(ftepp), ftepp_tokval(ftepp)); + return ftepp_warn(ftepp, WARN_CPP, "#warning %s", ftepp_tokval(ftepp)); +} + +static void ftepp_directive_error(ftepp_t *ftepp) { + char *message = NULL; + + if (!ftepp_skipspace(ftepp)) + return; + + /* handle the odd non string constant case so it works like C */ + if (ftepp->token != TOKEN_STRINGCONST) { + vec_upload(message, "#error", 6); + ftepp_next(ftepp); + while (ftepp->token != TOKEN_EOL) { + vec_upload(message, ftepp_tokval(ftepp), strlen(ftepp_tokval(ftepp))); + ftepp_next(ftepp); + } + vec_push(message, '\0'); + ftepp_error(ftepp, message); + vec_free(message); + return; + } + + unescape (ftepp_tokval(ftepp), ftepp_tokval(ftepp)); + ftepp_error(ftepp, "#error %s", ftepp_tokval(ftepp)); +} + /** * Include a file. * FIXME: do we need/want a -I option? @@ -1057,7 +1253,7 @@ static bool ftepp_include(ftepp_t *ftepp) } inlex = lex_open(filename); if (!inlex) { - ftepp_error(ftepp, "failed to open include file `%s`", filename); + ftepp_error(ftepp, "open failed on include file `%s`", filename); vec_free(filename); return false; } @@ -1214,9 +1410,22 @@ static bool ftepp_hash(ftepp_t *ftepp) ftepp_out(ftepp, "#", false); break; } + else if (!strcmp(ftepp_tokval(ftepp), "warning")) { + ftepp_directive_warning(ftepp); + break; + } + else if (!strcmp(ftepp_tokval(ftepp), "error")) { + ftepp_directive_error(ftepp); + 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; never reached */ default: @@ -1245,6 +1454,10 @@ static bool ftepp_preprocess(ftepp_t *ftepp) ppmacro *macro; bool newline = true; + /* predef stuff */ + char *expand = NULL; + size_t i; + ftepp->lex->flags.preprocessing = true; ftepp->lex->flags.mergelines = false; ftepp->lex->flags.noops = true; @@ -1255,18 +1468,32 @@ 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)); + /* is it a predef? */ + if (OPTS_FLAG(FTEPP_PREDEFS)) { + for (i = 0; i < sizeof(ftepp_predefs) / sizeof (*ftepp_predefs); i++) { + if (!strcmp(ftepp_predefs[i].name, ftepp_tokval(ftepp))) { + expand = ftepp_predefs[i].func(ftepp->lex); + ftepp_out(ftepp, expand, false); + ftepp_next(ftepp); /* skip */ + + mem_d(expand); /* free memory */ + break; + } + } + } + + 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); @@ -1276,7 +1503,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; @@ -1296,7 +1523,13 @@ 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; @@ -1307,8 +1540,7 @@ static bool ftepp_preprocess(ftepp_t *ftepp) vec_push(ftepp->output_string, 0); vec_shrinkby(ftepp->output_string, 1); - newline = ftepp->token == TOKEN_EOF; - return newline; + return (ftepp->token == TOKEN_EOF); } /* Like in parser.c - files keep the previous state so we have one global @@ -1358,20 +1590,69 @@ bool ftepp_preprocess_string(const char *name, const char *str) 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(); if (!ftepp) return false; - + + memset(minor, 0, sizeof(minor)); + memset(major, 0, sizeof(major)); + /* set the right macro based on the selected standard */ - if (opts_standard == COMPILER_FTEQCC) - ftepp_add_define(NULL, "FTEQCC"); - else if (opts_standard == COMPILER_GMQCC) - ftepp_add_define(NULL, "GMQCC"); - else if (opts_standard == COMPILER_QCC) - ftepp_add_define(NULL, "QCC"); - + 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; } @@ -1391,7 +1672,7 @@ const char *ftepp_get() void ftepp_flush() { - vec_free(ftepp->output_string); + ftepp_flush_do(ftepp); } void ftepp_finish()