X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ftepp.c;h=7b24c647eebaf940ac017bddc1ef2ced095c1ebf;hp=7337ba3571efec36117426617adadc856757991f;hb=641136fee3e2f589f93ad6a7b3213b0247107303;hpb=3e7340c52cf1c7d73aac9200a999f920104d9ee7 diff --git a/ftepp.c b/ftepp.c index 7337ba3..7b24c64 100644 --- a/ftepp.c +++ b/ftepp.c @@ -1,7 +1,7 @@ /* - * Copyright (C) 2012, 2013 + * Copyright (C) 2012, 2013, 2014 * Wolfgang Bumiller - * Dale Weiler + * 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 @@ -21,10 +21,15 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ -#include +#include +#include +#include + #include "gmqcc.h" #include "lexer.h" +#define HT_MACROS 1024 + typedef struct { bool on; bool was_on; @@ -36,7 +41,7 @@ typedef struct { char *value; /* a copy from the lexer */ union { - vector v; + vec3_t v; int i; double f; int t; /* type */ @@ -44,7 +49,7 @@ typedef struct { } pptoken; typedef struct { - lex_ctx ctx; + lex_ctx_t ctx; char *name; char **params; @@ -55,115 +60,126 @@ typedef struct { pptoken **output; } ppmacro; -typedef struct { +typedef struct ftepp_s { lex_file *lex; int token; unsigned int errors; bool output_on; ppcondition *conditions; - ppmacro **macros; - + /*ppmacro **macros;*/ + ht macros; /* hashtable */ char *output_string; char *itemname; char *includename; bool in_macro; -} 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; + uint32_t predef_countval; + uint32_t predef_randval; +} ftepp_t; /* __DATE__ */ -char *ftepp_predef_date(lex_file *context) { - struct tm *itime; - time_t rtime; - char *value = (char*)mem_a(82); - /* 82 is enough for strftime but we also have " " in our string */ +static char *ftepp_predef_date(ftepp_t *context) { + const struct tm *itime = NULL; + char *value = (char*)mem_a(82); + time_t rtime; (void)context; - /* get time */ time (&rtime); - itime = localtime(&rtime); - + itime = util_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 = (char*)mem_a(82); - /* 82 is enough for strftime but we also have " " in our string */ +static char *ftepp_predef_time(ftepp_t *context) { + const struct tm *itime = NULL; + char *value = (char*)mem_a(82); + time_t rtime; (void)context; - /* get time */ time (&rtime); - itime = localtime(&rtime); - + itime = util_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); +static char *ftepp_predef_line(ftepp_t *context) { + char *value; + + util_asprintf(&value, "%d", (int)context->lex->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); - snprintf(value, length, "\"%s\"", context->name); +static char *ftepp_predef_file(ftepp_t *context) { + size_t length = strlen(context->lex->name) + 3; /* two quotes and a terminator */ + char *value = (char*)mem_a(length); + util_snprintf(value, length, "\"%s\"", context->lex->name); return value; } /* __COUNTER_LAST__ */ -char *ftepp_predef_counterlast(lex_file *context) { - char *value; - util_asprintf(&value, "%u", ftepp_predef_countval); - - (void)context; +static char *ftepp_predef_counterlast(ftepp_t *context) { + char *value; + util_asprintf(&value, "%u", context->predef_countval); return value; } /* __COUNTER__ */ -char *ftepp_predef_counter(lex_file *context) { - char *value; - ftepp_predef_countval ++; - util_asprintf(&value, "%u", ftepp_predef_countval); - (void)context; +static char *ftepp_predef_counter(ftepp_t *context) { + char *value; + + context->predef_countval ++; + util_asprintf(&value, "%u", context->predef_countval); 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); +static char *ftepp_predef_random(ftepp_t *context) { + char *value; - (void)context; + context->predef_randval = (util_rand() % 0xFF) + 1; + util_asprintf(&value, "%u", context->predef_randval); return value; } /* __RANDOM_LAST__ */ -char *ftepp_predef_randomlast(lex_file *context) { - char *value; - util_asprintf(&value, "%u", ftepp_predef_randval); +static char *ftepp_predef_randomlast(ftepp_t *context) { + char *value; + + util_asprintf(&value, "%u", context->predef_randval); + return value; +} +/* __TIMESTAMP__ */ +static char *ftepp_predef_timestamp(ftepp_t *context) { + struct stat finfo; + const char *find; + char *value; + size_t size; + + if (stat(context->lex->name, &finfo)) + return util_strdup("\"\""); + + find = util_ctime(&finfo.st_mtime); + value = (char*)mem_a(strlen(find) + 1); + memcpy(&value[1], find, (size = strlen(find)) - 1); + + value[0] = '"'; + value[size] = '"'; - (void)context; return value; } -const ftepp_predef_t ftepp_predefs[FTEPP_PREDEF_COUNT] = { +typedef struct { + const char *name; + char *(*func)(ftepp_t *); +} ftepp_predef_t; + +static const ftepp_predef_t ftepp_predefs[] = { { "__LINE__", &ftepp_predef_line }, { "__FILE__", &ftepp_predef_file }, { "__COUNTER__", &ftepp_predef_counter }, @@ -171,20 +187,41 @@ const ftepp_predef_t ftepp_predefs[FTEPP_PREDEF_COUNT] = { { "__RANDOM__", &ftepp_predef_random }, { "__RANDOM_LAST__", &ftepp_predef_randomlast }, { "__DATE__", &ftepp_predef_date }, - { "__TIME__", &ftepp_predef_time } + { "__TIME__", &ftepp_predef_time }, + { "__TIME_STAMP__", &ftepp_predef_timestamp } }; +static GMQCC_INLINE size_t ftepp_predef_index(const char *name) { + /* no hashtable here, we simply check for one to exist the naive way */ + size_t i; + for(i = 1; i < GMQCC_ARRAY_COUNT(ftepp_predefs) + 1; i++) + if (!strcmp(ftepp_predefs[i-1].name, name)) + return i; + return 0; +} + +bool ftepp_predef_exists(const char *name); +bool ftepp_predef_exists(const char *name) { + return ftepp_predef_index(name) != 0; +} + +/* singleton because we're allowed */ +static GMQCC_INLINE char *(*ftepp_predef(const char *name))(ftepp_t *context) { + size_t i = ftepp_predef_index(name); + return (i != 0) ? ftepp_predefs[i-1].func : NULL; +} + #define ftepp_tokval(f) ((f)->lex->tok.value) #define ftepp_ctx(f) ((f)->lex->tok.ctx) -static void ftepp_errorat(ftepp_t *ftepp, lex_ctx ctx, const char *fmt, ...) +static void ftepp_errorat(ftepp_t *ftepp, lex_ctx_t ctx, const char *fmt, ...) { va_list ap; ftepp->errors++; va_start(ap, fmt); - con_cvprintmsg((void*)&ctx, LVL_ERROR, "error", fmt, ap); + con_cvprintmsg(ctx, LVL_ERROR, "error", fmt, ap); va_end(ap); } @@ -195,7 +232,7 @@ static void ftepp_error(ftepp_t *ftepp, const char *fmt, ...) ftepp->errors++; va_start(ap, fmt); - con_cvprintmsg((void*)&ftepp->lex->tok.ctx, LVL_ERROR, "error", fmt, ap); + con_cvprintmsg(ftepp->lex->tok.ctx, LVL_ERROR, "error", fmt, ap); va_end(ap); } @@ -225,13 +262,13 @@ static pptoken *pptoken_make(ftepp_t *ftepp) return token; } -static void pptoken_delete(pptoken *self) +static GMQCC_INLINE void pptoken_delete(pptoken *self) { mem_d(self->value); mem_d(self); } -static ppmacro *ppmacro_new(lex_ctx ctx, const char *name) +static ppmacro *ppmacro_new(lex_ctx_t ctx, const char *name) { ppmacro *macro = (ppmacro*)mem_a(sizeof(ppmacro)); @@ -254,34 +291,36 @@ static void ppmacro_delete(ppmacro *self) mem_d(self); } -static ftepp_t* ftepp_new() +static ftepp_t* ftepp_new(void) { ftepp_t *ftepp; ftepp = (ftepp_t*)mem_a(sizeof(*ftepp)); memset(ftepp, 0, sizeof(*ftepp)); - ftepp->output_on = true; + ftepp->macros = util_htnew(HT_MACROS); + ftepp->output_on = true; + ftepp->predef_countval = 0; + ftepp->predef_randval = 0; return ftepp; } -static void ftepp_flush_do(ftepp_t *self) +static GMQCC_INLINE 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) vec_free(self->includename); - for (i = 0; i < vec_size(self->macros); ++i) - ppmacro_delete(self->macros[i]); - vec_free(self->macros); + + util_htrem(self->macros, (void (*)(void*))&ppmacro_delete); + vec_free(self->conditions); if (self->lex) lex_close(self->lex); @@ -300,7 +339,7 @@ static void ftepp_out(ftepp_t *ftepp, const char *str, bool ignore_cond) } } -static void ftepp_update_output_condition(ftepp_t *ftepp) +static GMQCC_INLINE void ftepp_update_output_condition(ftepp_t *ftepp) { size_t i; ftepp->output_on = true; @@ -308,25 +347,14 @@ static void ftepp_update_output_condition(ftepp_t *ftepp) ftepp->output_on = ftepp->output_on && ftepp->conditions[i].on; } -static ppmacro* ftepp_macro_find(ftepp_t *ftepp, const char *name) +static GMQCC_INLINE ppmacro* ftepp_macro_find(ftepp_t *ftepp, const char *name) { - size_t i; - for (i = 0; i < vec_size(ftepp->macros); ++i) { - if (!strcmp(name, ftepp->macros[i]->name)) - return ftepp->macros[i]; - } - return NULL; + return (ppmacro*)util_htget(ftepp->macros, name); } -static void ftepp_macro_delete(ftepp_t *ftepp, const char *name) +static GMQCC_INLINE void ftepp_macro_delete(ftepp_t *ftepp, const char *name) { - size_t i; - for (i = 0; i < vec_size(ftepp->macros); ++i) { - if (!strcmp(name, ftepp->macros[i]->name)) { - vec_remove(ftepp->macros, i, 1); - return; - } - } + util_htrm(ftepp->macros, name, (void (*)(void*))&ppmacro_delete); } static GMQCC_INLINE int ftepp_next(ftepp_t *ftepp) @@ -394,6 +422,7 @@ static bool ftepp_define_params(ftepp_t *ftepp, ppmacro *macro) return false; } } while (ftepp->token == ','); + if (ftepp->token != ')') { ftepp_error(ftepp, "expected closing paren after macro parameter list"); return false; @@ -469,10 +498,29 @@ static bool ftepp_define_body(ftepp_t *ftepp, ppmacro *macro) return true; } +static const char *ftepp_math_constants[][2] = { + { "M_E", "2.7182818284590452354" }, /* e */ + { "M_LOG2E", "1.4426950408889634074" }, /* log_2 e */ + { "M_LOG10E", "0.43429448190325182765" }, /* log_10 e */ + { "M_LN2", "0.69314718055994530942" }, /* log_e 2 */ + { "M_LN10", "2.30258509299404568402" }, /* log_e 10 */ + { "M_PI", "3.14159265358979323846" }, /* pi */ + { "M_PI_2", "1.57079632679489661923" }, /* pi/2 */ + { "M_PI_4", "0.78539816339744830962" }, /* pi/4 */ + { "M_1_PI", "0.31830988618379067154" }, /* 1/pi */ + { "M_2_PI", "0.63661977236758134308" }, /* 2/pi */ + { "M_2_SQRTPI", "1.12837916709551257390" }, /* 2/sqrt(pi) */ + { "M_SQRT2", "1.41421356237309504880" }, /* sqrt(2) */ + { "M_SQRT1_2", "0.70710678118654752440" }, /* 1/sqrt(2) */ + { "M_TAU", "6.28318530717958647692" } /* pi*2 */ +}; + static bool ftepp_define(ftepp_t *ftepp) { ppmacro *macro = NULL; size_t l = ftepp_ctx(ftepp).line; + size_t i; + bool mathconstant = false; (void)ftepp_next(ftepp); if (!ftepp_skipspace(ftepp)) @@ -482,7 +530,25 @@ static bool ftepp_define(ftepp_t *ftepp) case TOKEN_IDENT: case TOKEN_TYPENAME: case TOKEN_KEYWORD: + if (OPTS_FLAG(FTEPP_MATHDEFS)) { + for (i = 0; i < GMQCC_ARRAY_COUNT(ftepp_math_constants); i++) { + if (!strcmp(ftepp_math_constants[i][0], ftepp_tokval(ftepp))) { + mathconstant = true; + break; + } + } + } + macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp)); + + if (OPTS_FLAG(FTEPP_MATHDEFS)) { + /* user defined ones take precedence */ + if (macro && mathconstant) { + ftepp_macro_delete(ftepp, ftepp_tokval(ftepp)); + macro = NULL; + } + } + if (macro && ftepp->output_on) { if (ftepp_warn(ftepp, WARN_CPP, "redefining `%s`", ftepp_tokval(ftepp))) return false; @@ -492,25 +558,31 @@ static bool ftepp_define(ftepp_t *ftepp) break; default: ftepp_error(ftepp, "expected macro name"); - goto cleanup_false; + return false; } (void)ftepp_next(ftepp); if (ftepp->token == '(') { macro->has_params = true; - if (!ftepp_define_params(ftepp, macro)) - goto cleanup_false; + if (!ftepp_define_params(ftepp, macro)) { + ppmacro_delete(macro); + return false; + } } - if (!ftepp_skipspace(ftepp)) - goto cleanup_false; + if (!ftepp_skipspace(ftepp)) { + ppmacro_delete(macro); + return false; + } - if (!ftepp_define_body(ftepp, macro)) - goto cleanup_false; + if (!ftepp_define_body(ftepp, macro)) { + ppmacro_delete(macro); + return false; + } if (ftepp->output_on) - vec_push(ftepp->macros, macro); + util_htset(ftepp->macros, macro->name, (void*)macro); else { ppmacro_delete(macro); } @@ -518,10 +590,6 @@ static bool ftepp_define(ftepp_t *ftepp) for (; l < ftepp_ctx(ftepp).line; ++l) ftepp_out(ftepp, "\n", true); return true; - -cleanup_false: - if (macro) ppmacro_delete(macro); - return false; } /** @@ -570,7 +638,7 @@ static bool ftepp_macro_call_params(ftepp_t *ftepp, macroparam **out_params) ptok = pptoken_make(ftepp); vec_push(mp.tokens, ptok); if (ftepp_next(ftepp) >= TOKEN_EOF) { - ftepp_error(ftepp, "unexpected EOF in macro call"); + ftepp_error(ftepp, "unexpected end of file in macro call"); goto on_error; } } @@ -583,16 +651,10 @@ static bool ftepp_macro_call_params(ftepp_t *ftepp, macroparam **out_params) goto on_error; } if (ftepp_next(ftepp) >= TOKEN_EOF) { - ftepp_error(ftepp, "unexpected EOF in macro call"); + ftepp_error(ftepp, "unexpected end of file in macro call"); goto on_error; } } - /* need to leave that up - if (ftepp_next(ftepp) >= TOKEN_EOF) { - ftepp_error(ftepp, "unexpected EOF in macro call"); - goto on_error; - } - */ *out_params = params; return true; @@ -672,6 +734,7 @@ static void ftepp_recursion_footer(ftepp_t *ftepp) ftepp_out(ftepp, "\n#pragma pop(line)\n", false); } +static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *params, bool resetline); static void ftepp_param_out(ftepp_t *ftepp, macroparam *param) { size_t i; @@ -680,8 +743,13 @@ static void ftepp_param_out(ftepp_t *ftepp, macroparam *param) out = param->tokens[i]; if (out->token == TOKEN_EOL) ftepp_out(ftepp, "\n", false); - else - ftepp_out(ftepp, out->value, false); + else { + ppmacro *find = ftepp_macro_find(ftepp, out->value); + if (OPTS_FLAG(FTEPP_INDIRECT_EXPANSION) && find && !find->has_params) + ftepp_macro_expand(ftepp, find, NULL, false); + else + ftepp_out(ftepp, out->value, false); + } } } @@ -701,6 +769,7 @@ static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *param lex_file *inlex; bool old_inmacro; + bool strip = false; int nextok; @@ -765,6 +834,7 @@ static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *param if (nextok == '#') { /* raw concatenation */ ++o; + strip = true; break; } if ( (nextok == TOKEN_IDENT || @@ -773,6 +843,7 @@ static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *param macro_params_find(macro, macro->output[o+1]->value, &pi)) { ++o; + ftepp_stringify(ftepp, ¶ms[pi]); break; } @@ -783,7 +854,15 @@ static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *param ftepp_out(ftepp, "\n", false); break; default: - ftepp_out(ftepp, out->value, false); + buffer = out->value; + #define buffer_stripable(X) ((X) == ' ' || (X) == '\t') + if (vec_size(macro->output) > o + 1 && macro->output[o+1]->token == '#' && buffer_stripable(*buffer)) + buffer++; + if (strip) { + while (buffer_stripable(*buffer)) buffer++; + strip = false; + } + ftepp_out(ftepp, buffer, false); break; } } @@ -834,7 +913,7 @@ static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *param if (resetline && !ftepp->in_macro) { char lineno[128]; - snprintf(lineno, 128, "\n#pragma line(%lu)\n", (unsigned long)(old_lexer->sline)); + util_snprintf(lineno, 128, "\n#pragma line(%lu)\n", (unsigned long)(old_lexer->sline)); ftepp_out(ftepp, lineno, false); } @@ -1244,7 +1323,7 @@ static void unescape(const char *str, char *out) { static char *ftepp_include_find_path(const char *file, const char *pathfile) { - FILE *fp; + fs_file_t *fp; char *filename = NULL; const char *last_slash; size_t len; @@ -1292,10 +1371,10 @@ static bool ftepp_directive_warning(ftepp_t *ftepp) { /* 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); + vec_append(message, 8, "#warning"); ftepp_next(ftepp); while (ftepp->token != TOKEN_EOL) { - vec_upload(message, ftepp_tokval(ftepp), strlen(ftepp_tokval(ftepp))); + vec_append(message, strlen(ftepp_tokval(ftepp)), ftepp_tokval(ftepp)); ftepp_next(ftepp); } vec_push(message, '\0'); @@ -1322,10 +1401,10 @@ static void ftepp_directive_error(ftepp_t *ftepp) { /* handle the odd non string constant case so it works like C */ if (ftepp->token != TOKEN_STRINGCONST) { - vec_upload(message, "#error", 6); + vec_append(message, 6, "#error"); ftepp_next(ftepp); while (ftepp->token != TOKEN_EOL) { - vec_upload(message, ftepp_tokval(ftepp), strlen(ftepp_tokval(ftepp))); + vec_append(message, strlen(ftepp_tokval(ftepp)), ftepp_tokval(ftepp)); ftepp_next(ftepp); } vec_push(message, '\0'); @@ -1350,15 +1429,15 @@ static void ftepp_directive_message(ftepp_t *ftepp) { /* handle the odd non string constant case so it works like C */ if (ftepp->token != TOKEN_STRINGCONST) { - vec_upload(message, "#message", 8); + vec_append(message, 8, "#message"); ftepp_next(ftepp); while (ftepp->token != TOKEN_EOL) { - vec_upload(message, ftepp_tokval(ftepp), strlen(ftepp_tokval(ftepp))); + vec_append(message, strlen(ftepp_tokval(ftepp)), ftepp_tokval(ftepp)); ftepp_next(ftepp); } vec_push(message, '\0'); if (ftepp->output_on) - con_cprintmsg(&ftepp->lex->tok.ctx, LVL_MSG, "message", message); + con_cprintmsg(ftepp->lex->tok.ctx, LVL_MSG, "message", message); vec_free(message); return; } @@ -1367,7 +1446,7 @@ static void ftepp_directive_message(ftepp_t *ftepp) { return; unescape (ftepp_tokval(ftepp), ftepp_tokval(ftepp)); - con_cprintmsg(&ftepp->lex->tok.ctx, LVL_MSG, "message", ftepp_tokval(ftepp)); + con_cprintmsg(ftepp->lex->tok.ctx, LVL_MSG, "message", ftepp_tokval(ftepp)); } /** @@ -1379,7 +1458,7 @@ static bool ftepp_include(ftepp_t *ftepp) { lex_file *old_lexer = ftepp->lex; lex_file *inlex; - lex_ctx ctx; + lex_ctx_t ctx; char lineno[128]; char *filename; char *old_includename; @@ -1434,7 +1513,7 @@ static bool ftepp_include(ftepp_t *ftepp) 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)); + util_snprintf(lineno, sizeof(lineno), ")\n#pragma line(%lu)\n", (unsigned long)(ctx.line+1)); ftepp_out(ftepp, lineno, false); /* skip the line */ @@ -1464,12 +1543,17 @@ static bool ftepp_else_allowed(ftepp_t *ftepp) return true; } +static GMQCC_INLINE void ftepp_inmacro(ftepp_t *ftepp, const char *hash) { + if (ftepp->in_macro) + (void)!ftepp_warn(ftepp, WARN_DIRECTIVE_INMACRO, "`#%s` directive in macro", hash); +} + static bool ftepp_hash(ftepp_t *ftepp) { ppcondition cond; ppcondition *pc; - lex_ctx ctx = ftepp_ctx(ftepp); + lex_ctx_t ctx = ftepp_ctx(ftepp); if (!ftepp_skipspace(ftepp)) return false; @@ -1479,12 +1563,15 @@ static bool ftepp_hash(ftepp_t *ftepp) case TOKEN_IDENT: case TOKEN_TYPENAME: if (!strcmp(ftepp_tokval(ftepp), "define")) { + ftepp_inmacro(ftepp, "define"); return ftepp_define(ftepp); } else if (!strcmp(ftepp_tokval(ftepp), "undef")) { + ftepp_inmacro(ftepp, "undef"); return ftepp_undef(ftepp); } else if (!strcmp(ftepp_tokval(ftepp), "ifdef")) { + ftepp_inmacro(ftepp, "ifdef"); if (!ftepp_ifdef(ftepp, &cond)) return false; cond.was_on = cond.on; @@ -1493,6 +1580,7 @@ static bool ftepp_hash(ftepp_t *ftepp) break; } else if (!strcmp(ftepp_tokval(ftepp), "ifndef")) { + ftepp_inmacro(ftepp, "ifndef"); if (!ftepp_ifdef(ftepp, &cond)) return false; cond.on = !cond.on; @@ -1502,6 +1590,7 @@ static bool ftepp_hash(ftepp_t *ftepp) break; } else if (!strcmp(ftepp_tokval(ftepp), "elifdef")) { + ftepp_inmacro(ftepp, "elifdef"); if (!ftepp_else_allowed(ftepp)) return false; if (!ftepp_ifdef(ftepp, &cond)) @@ -1513,6 +1602,7 @@ static bool ftepp_hash(ftepp_t *ftepp) break; } else if (!strcmp(ftepp_tokval(ftepp), "elifndef")) { + ftepp_inmacro(ftepp, "elifndef"); if (!ftepp_else_allowed(ftepp)) return false; if (!ftepp_ifdef(ftepp, &cond)) @@ -1525,6 +1615,7 @@ static bool ftepp_hash(ftepp_t *ftepp) break; } else if (!strcmp(ftepp_tokval(ftepp), "elif")) { + ftepp_inmacro(ftepp, "elif"); if (!ftepp_else_allowed(ftepp)) return false; if (!ftepp_if(ftepp, &cond)) @@ -1536,6 +1627,7 @@ static bool ftepp_hash(ftepp_t *ftepp) break; } else if (!strcmp(ftepp_tokval(ftepp), "if")) { + ftepp_inmacro(ftepp, "if"); if (!ftepp_if(ftepp, &cond)) return false; cond.was_on = cond.on; @@ -1544,6 +1636,7 @@ static bool ftepp_hash(ftepp_t *ftepp) break; } else if (!strcmp(ftepp_tokval(ftepp), "else")) { + ftepp_inmacro(ftepp, "else"); if (!ftepp_else_allowed(ftepp)) return false; pc = &vec_last(ftepp->conditions); @@ -1554,6 +1647,7 @@ static bool ftepp_hash(ftepp_t *ftepp) break; } else if (!strcmp(ftepp_tokval(ftepp), "endif")) { + ftepp_inmacro(ftepp, "endif"); if (!vec_size(ftepp->conditions)) { ftepp_error(ftepp, "#endif without #if"); return false; @@ -1564,6 +1658,7 @@ static bool ftepp_hash(ftepp_t *ftepp) break; } else if (!strcmp(ftepp_tokval(ftepp), "include")) { + ftepp_inmacro(ftepp, "include"); return ftepp_include(ftepp); } else if (!strcmp(ftepp_tokval(ftepp), "pragma")) { @@ -1620,7 +1715,6 @@ static bool ftepp_preprocess(ftepp_t *ftepp) /* predef stuff */ char *expand = NULL; - size_t i; ftepp->lex->flags.preprocessing = true; ftepp->lex->flags.mergelines = false; @@ -1641,15 +1735,14 @@ static bool ftepp_preprocess(ftepp_t *ftepp) case TOKEN_TYPENAME: /* 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; - } + char *(*predef)(ftepp_t*) = ftepp_predef(ftepp_tokval(ftepp)); + if (predef) { + expand = predef(ftepp); + ftepp_out (ftepp, expand, false); + ftepp_next(ftepp); + + mem_d(expand); + break; } } @@ -1710,9 +1803,7 @@ static bool ftepp_preprocess(ftepp_t *ftepp) /* Like in parser.c - files keep the previous state so we have one global * preprocessor. Except here we will want to warn about dangling #ifs. */ -static ftepp_t *ftepp; - -static bool ftepp_preprocess_done() +static bool ftepp_preprocess_done(ftepp_t *ftepp) { bool retval = true; if (vec_size(ftepp->conditions)) { @@ -1728,7 +1819,7 @@ static bool ftepp_preprocess_done() return retval; } -bool ftepp_preprocess_file(const char *filename) +bool ftepp_preprocess_file(ftepp_t *ftepp, const char *filename) { ftepp->lex = lex_open(filename); ftepp->itemname = util_strdup(filename); @@ -1738,10 +1829,10 @@ bool ftepp_preprocess_file(const char *filename) } if (!ftepp_preprocess(ftepp)) return false; - return ftepp_preprocess_done(); + return ftepp_preprocess_done(ftepp); } -bool ftepp_preprocess_string(const char *name, const char *str) +bool ftepp_preprocess_string(ftepp_t *ftepp, const char *name, const char *str) { ftepp->lex = lex_open_string(str, strlen(str), name); ftepp->itemname = util_strdup(name); @@ -1751,45 +1842,47 @@ bool ftepp_preprocess_string(const char *name, const char *str) } if (!ftepp_preprocess(ftepp)) return false; - return ftepp_preprocess_done(); + return ftepp_preprocess_done(ftepp); } -void ftepp_add_macro(const char *name, const char *value) { +void ftepp_add_macro(ftepp_t *ftepp, const char *name, const char *value) { char *create = NULL; /* use saner path for empty macros */ if (!value) { - ftepp_add_define("__builtin__", name); + ftepp_add_define(ftepp, "__builtin__", name); return; } - vec_upload(create, "#define ", 8); - vec_upload(create, name, strlen(name)); + vec_append(create, 8, "#define "); + vec_append(create, strlen(name), name); vec_push (create, ' '); - vec_upload(create, value, strlen(value)); + vec_append(create, strlen(value), value); vec_push (create, 0); - ftepp_preprocess_string("__builtin__", create); + ftepp_preprocess_string(ftepp, "__builtin__", create); vec_free (create); } -bool ftepp_init() +ftepp_t *ftepp_create() { + ftepp_t *ftepp; char minor[32]; char major[32]; + size_t i; ftepp = ftepp_new(); if (!ftepp) - return false; + return NULL; memset(minor, 0, sizeof(minor)); memset(major, 0, sizeof(major)); /* set the right macro based on the selected standard */ - ftepp_add_define(NULL, "GMQCC"); + ftepp_add_define(ftepp, NULL, "GMQCC"); if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_FTEQCC) { - ftepp_add_define(NULL, "__STD_FTEQCC__"); + ftepp_add_define(ftepp, NULL, "__STD_FTEQCC__"); /* 1.00 */ major[0] = '"'; major[1] = '1'; @@ -1799,15 +1892,15 @@ bool ftepp_init() minor[1] = '0'; minor[2] = '"'; } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) { - ftepp_add_define(NULL, "__STD_GMQCC__"); - snprintf(major, 32, "\"%d\"", GMQCC_VERSION_MAJOR); - snprintf(minor, 32, "\"%d\"", GMQCC_VERSION_MINOR); + ftepp_add_define(ftepp, NULL, "__STD_GMQCC__"); + util_snprintf(major, 32, "\"%d\"", GMQCC_VERSION_MAJOR); + util_snprintf(minor, 32, "\"%d\"", GMQCC_VERSION_MINOR); } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCCX) { - ftepp_add_define(NULL, "__STD_QCCX__"); - snprintf(major, 32, "\"%d\"", GMQCC_VERSION_MAJOR); - snprintf(minor, 32, "\"%d\"", GMQCC_VERSION_MINOR); + ftepp_add_define(ftepp, NULL, "__STD_QCCX__"); + util_snprintf(major, 32, "\"%d\"", GMQCC_VERSION_MAJOR); + util_snprintf(minor, 32, "\"%d\"", GMQCC_VERSION_MINOR); } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) { - ftepp_add_define(NULL, "__STD_QCC__"); + ftepp_add_define(ftepp, NULL, "__STD_QCC__"); /* 1.0 */ major[0] = '"'; major[1] = '1'; @@ -1818,35 +1911,48 @@ bool ftepp_init() minor[2] = '"'; } - ftepp_add_macro("__STD_VERSION_MINOR__", minor); - ftepp_add_macro("__STD_VERSION_MAJOR__", major); + ftepp_add_macro(ftepp, "__STD_VERSION_MINOR__", minor); + ftepp_add_macro(ftepp, "__STD_VERSION_MAJOR__", major); - return true; + /* + * We're going to just make __NULL__ nil, which works for 60% of the + * cases of __NULL_ for fteqcc. + */ + ftepp_add_macro(ftepp, "__NULL__", "nil"); + + /* add all the math constants if they can be */ + if (OPTS_FLAG(FTEPP_MATHDEFS)) { + for (i = 0; i < GMQCC_ARRAY_COUNT(ftepp_math_constants); i++) + if (!ftepp_macro_find(ftepp, ftepp_math_constants[i][0])) + ftepp_add_macro(ftepp, ftepp_math_constants[i][0], ftepp_math_constants[i][1]); + } + + return ftepp; } -void ftepp_add_define(const char *source, const char *name) +void ftepp_add_define(ftepp_t *ftepp, const char *source, const char *name) { ppmacro *macro; - lex_ctx ctx = { "__builtin__", 0 }; + lex_ctx_t ctx = { "__builtin__", 0, 0 }; ctx.file = source; macro = ppmacro_new(ctx, name); - vec_push(ftepp->macros, macro); + /*vec_push(ftepp->macros, macro);*/ + util_htset(ftepp->macros, name, macro); } -const char *ftepp_get() +const char *ftepp_get(ftepp_t *ftepp) { return ftepp->output_string; } -void ftepp_flush() +void ftepp_flush(ftepp_t *ftepp) { ftepp_flush_do(ftepp); } -void ftepp_finish() +void ftepp_finish(ftepp_t *ftepp) { if (!ftepp) return; ftepp_delete(ftepp); - ftepp = NULL; }