X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ftepp.c;h=7969231299a00b2dd8f06bafa0d33e2c8f838bde;hb=613e1e7247c8dd271979b9e9d70ff7735ef5282b;hp=cdc0d1e10ac66cbabb8f692fa488dcd9fb3b72a8;hpb=0ad2b8b2c7a7fff3d32afe31de0d23400ed3a615;p=xonotic%2Fgmqcc.git

diff --git a/ftepp.c b/ftepp.c
index cdc0d1e..7969231 100644
--- a/ftepp.c
+++ b/ftepp.c
@@ -62,8 +62,10 @@ typedef struct {
     ppcondition *conditions;
     ppmacro    **macros;
 
-    bool         output_string;
-    char        *output;
+    char        *output_string;
+
+    char        *itemname;
+    char        *includename;
 } ftepp_t;
 
 #define ftepp_tokval(f) ((f)->lex->tok.value)
@@ -76,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);
 }
 
@@ -87,18 +89,40 @@ 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, ...)
+{
+    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);
+    va_end(ap);
+    return opts_werror;
+}
+
 static pptoken *pptoken_make(ftepp_t *ftepp)
 {
     pptoken *token = (pptoken*)mem_a(sizeof(pptoken));
     token->token = ftepp->token;
+#if 0
     if (token->token == TOKEN_WHITE)
         token->value = util_strdup(" ");
     else
+#else
         token->value = util_strdup(ftepp_tokval(ftepp));
+#endif
     memcpy(&token->constval, &ftepp->lex->tok.constval, sizeof(token->constval));
     return token;
 }
@@ -112,6 +136,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;
@@ -130,7 +156,7 @@ static void ppmacro_delete(ppmacro *self)
     mem_d(self);
 }
 
-static ftepp_t* ftepp_init()
+static ftepp_t* ftepp_new()
 {
     ftepp_t *ftepp;
 
@@ -145,11 +171,16 @@ static ftepp_t* ftepp_init()
 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);
     vec_free(self->conditions);
-    lex_close(self->lex);
+    if (self->lex)
+        lex_close(self->lex);
     mem_d(self);
 }
 
@@ -159,12 +190,8 @@ static void ftepp_out(ftepp_t *ftepp, const char *str, bool ignore_cond)
     {
         size_t len;
         char  *data;
-        if (!ftepp->output_string) {
-            printf("%s", str);
-            return;
-        }
         len = strlen(str);
-        data = vec_add(ftepp->output, len);
+        data = vec_add(ftepp->output_string, len);
         memcpy(data, str, len);
     }
 }
@@ -187,6 +214,17 @@ static ppmacro* ftepp_macro_find(ftepp_t *ftepp, const char *name)
     return NULL;
 }
 
+static 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;
+        }
+    }
+}
+
 static inline int ftepp_next(ftepp_t *ftepp)
 {
     return (ftepp->token = lex_do(ftepp->lex));
@@ -262,7 +300,8 @@ static bool ftepp_define_body(ftepp_t *ftepp, ppmacro *macro)
         vec_push(macro->output, ptok);
         ftepp_next(ftepp);
     }
-    if (ftepp->token != TOKEN_EOL) {
+    /* recursive expansion can cause EOFs here */
+    if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
         ftepp_error(ftepp, "unexpected junk after macro or unexpected end of file");
         return false;
     }
@@ -280,6 +319,12 @@ static bool ftepp_define(ftepp_t *ftepp)
         case TOKEN_IDENT:
         case TOKEN_TYPENAME:
         case TOKEN_KEYWORD:
+            macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
+            if (macro && ftepp->output_on) {
+                if (ftepp_warn(ftepp, WARN_PREPROCESSOR, "redefining `%s`", ftepp_tokval(ftepp)))
+                    return false;
+                ftepp_macro_delete(ftepp, ftepp_tokval(ftepp));
+            }
             macro = ppmacro_new(ftepp_ctx(ftepp), ftepp_tokval(ftepp));
             break;
         default:
@@ -301,7 +346,11 @@ static bool ftepp_define(ftepp_t *ftepp)
     if (!ftepp_define_body(ftepp, macro))
         return false;
 
-    vec_push(ftepp->macros, macro);
+    if (ftepp->output_on)
+        vec_push(ftepp->macros, macro);
+    else {
+        ppmacro_delete(macro);
+    }
     return true;
 }
 
@@ -398,23 +447,78 @@ static bool macro_params_find(ppmacro *macro, const char *name, size_t *idx)
     return false;
 }
 
+static void ftepp_stringify_token(ftepp_t *ftepp, pptoken *token)
+{
+    char        chs[2];
+    const char *ch;
+    chs[1] = 0;
+    switch (token->token) {
+        case TOKEN_STRINGCONST:
+            ch = token->value;
+            while (*ch) {
+                /* in preprocessor mode strings already are string,
+                 * so we don't get actual newline bytes here.
+                 * Still need to escape backslashes and quotes.
+                 */
+                switch (*ch) {
+                    case '\\': ftepp_out(ftepp, "\\\\", false); break;
+                    case '"':  ftepp_out(ftepp, "\\\"", false); break;
+                    default:
+                        chs[0] = *ch;
+                        ftepp_out(ftepp, chs, false);
+                        break;
+                }
+                ++ch;
+            }
+            break;
+        case TOKEN_WHITE:
+            ftepp_out(ftepp, " ", false);
+            break;
+        case TOKEN_EOL:
+            ftepp_out(ftepp, "\\n", false);
+            break;
+        default:
+            ftepp_out(ftepp, token->value, false);
+            break;
+    }
+}
+
+static void ftepp_stringify(ftepp_t *ftepp, macroparam *param)
+{
+    size_t i;
+    ftepp_out(ftepp, "\"", false);
+    for (i = 0; i < vec_size(param->tokens); ++i)
+        ftepp_stringify_token(ftepp, param->tokens[i]);
+    ftepp_out(ftepp, "\"", false);
+}
+
+static void ftepp_recursion_header(ftepp_t *ftepp)
+{
+    ftepp_out(ftepp, "\n#pragma push(line)\n", false);
+}
+
+static void ftepp_recursion_footer(ftepp_t *ftepp)
+{
+    ftepp_out(ftepp, "\n#pragma pop(line)\n", 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;
-    bool      old_string_flag = ftepp->output_string;
+    char     *old_string = ftepp->output_string;
     lex_file *old_lexer = ftepp->lex;
     bool retval = true;
 
     size_t    o, pi, pv;
     lex_file *inlex;
 
+    int nextok;
+
     /* really ... */
     if (!vec_size(macro->output))
         return true;
 
-    ftepp->output = NULL;
-    ftepp->output_string = true;
+    ftepp->output_string = NULL;
     for (o = 0; o < vec_size(macro->output); ++o) {
         pptoken *out = macro->output[o];
         switch (out->token) {
@@ -434,6 +538,26 @@ static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *param
                     }
                 }
                 break;
+            case '#':
+                if (o + 1 < vec_size(macro->output)) {
+                    nextok = macro->output[o+1]->token;
+                    if (nextok == '#') {
+                        /* raw concatenation */
+                        ++o;
+                        break;
+                    }
+                    if ( (nextok == TOKEN_IDENT    ||
+                          nextok == TOKEN_KEYWORD  ||
+                          nextok == TOKEN_TYPENAME) &&
+                        macro_params_find(macro, macro->output[o+1]->value, &pi))
+                    {
+                        ++o;
+                        ftepp_stringify(ftepp, &params[pi]);
+                        break;
+                    }
+                }
+                ftepp_out(ftepp, "#", false);
+                break;
             case TOKEN_EOL:
                 ftepp_out(ftepp, "\n", false);
                 break;
@@ -442,27 +566,31 @@ static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *param
                 break;
         }
     }
-    vec_push(ftepp->output, 0);
+    vec_push(ftepp->output_string, 0);
     /* Now run the preprocessor recursively on this string buffer */
-    printf("__________\n%s\n=========\n", ftepp->output);
-    inlex = lex_open_string(ftepp->output, vec_size(ftepp->output)-1, ftepp->lex->name);
+    /*
+    printf("__________\n%s\n=========\n", ftepp->output_string);
+    */
+    inlex = lex_open_string(ftepp->output_string, vec_size(ftepp->output_string)-1, ftepp->lex->name);
     if (!inlex) {
         ftepp_error(ftepp, "internal error: failed to instantiate lexer");
         retval = false;
         goto cleanup;
     }
-    ftepp->output        = old_string;
-    ftepp->output_string = old_string_flag;
+    ftepp->output_string = old_string;
     ftepp->lex = inlex;
+    ftepp_recursion_header(ftepp);
     if (!ftepp_preprocess(ftepp)) {
+        lex_close(ftepp->lex);
         retval = false;
         goto cleanup;
     }
+    ftepp_recursion_footer(ftepp);
+    old_string = ftepp->output_string;
 
 cleanup:
     ftepp->lex           = old_lexer;
-    ftepp->output        = old_string;
-    ftepp->output_string = old_string_flag;
+    ftepp->output_string = old_string;
     return retval;
 }
 
@@ -527,7 +655,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;
@@ -579,13 +717,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:
@@ -598,15 +739,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");
@@ -615,38 +758,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_if_op(ftepp))
+        return false;
 
-    if (ftepp->token != TOKEN_OPERATOR)
+    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 {
@@ -658,6 +852,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);
@@ -669,7 +864,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;
@@ -701,14 +896,204 @@ static bool ftepp_ifdef(ftepp_t *ftepp, ppcondition *cond)
     (void)ftepp_next(ftepp);
     if (!ftepp_skipspace(ftepp))
         return false;
-    if (ftepp->token != TOKEN_EOL) {
+    /* relaxing this condition
+    if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
         ftepp_error(ftepp, "stray tokens after #ifdef");
         return false;
     }
+    */
     cond->on = !!macro;
     return true;
 }
 
+/**
+ * undef is also simple
+ */
+static bool ftepp_undef(ftepp_t *ftepp)
+{
+    (void)ftepp_next(ftepp);
+    if (!ftepp_skipspace(ftepp))
+        return false;
+
+    if (ftepp->output_on) {
+        switch (ftepp->token) {
+            case TOKEN_IDENT:
+            case TOKEN_TYPENAME:
+            case TOKEN_KEYWORD:
+                ftepp_macro_delete(ftepp, ftepp_tokval(ftepp));
+                break;
+            default:
+                ftepp_error(ftepp, "expected macro name");
+                return false;
+        }
+    }
+
+    (void)ftepp_next(ftepp);
+    if (!ftepp_skipspace(ftepp))
+        return false;
+    /* relaxing this condition
+    if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
+        ftepp_error(ftepp, "stray tokens after #ifdef");
+        return false;
+    }
+    */
+    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, '/');
+    }
+    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");
+    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, "failed to open 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)
 {
@@ -740,6 +1125,9 @@ static bool ftepp_hash(ftepp_t *ftepp)
             if (!strcmp(ftepp_tokval(ftepp), "define")) {
                 return ftepp_define(ftepp);
             }
+            else if (!strcmp(ftepp_tokval(ftepp), "undef")) {
+                return ftepp_undef(ftepp);
+            }
             else if (!strcmp(ftepp_tokval(ftepp), "ifdef")) {
                 if (!ftepp_ifdef(ftepp, &cond))
                     return false;
@@ -819,11 +1207,18 @@ 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;
             }
-            break;
+            /* break; never reached */
         default:
             ftepp_error(ftepp, "unexpected preprocessor token: `%s`", ftepp_tokval(ftepp));
             return false;
@@ -908,38 +1303,101 @@ static bool ftepp_preprocess(ftepp_t *ftepp)
         }
     } while (!ftepp->errors && ftepp->token < TOKEN_EOF);
 
+    /* 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);
+
     newline = ftepp->token == TOKEN_EOF;
     return newline;
 }
 
+/* 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()
+{
+    bool retval = true;
+    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_t *ftepp = ftepp_init();
     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;
-    }
-    ftepp_delete(ftepp);
-    return true;
+    return ftepp_preprocess_done();
 }
 
 bool ftepp_preprocess_string(const char *name, const char *str)
 {
-    ftepp_t *ftepp = ftepp_init();
     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;
-    }
-    ftepp_delete(ftepp);
+    return ftepp_preprocess_done();
+}
+
+bool ftepp_init()
+{
+    ftepp = ftepp_new();
+    if (!ftepp)
+        return false;
+    
+    /* 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");
+    
     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()
+{
+    return ftepp->output_string;
+}
+
+void ftepp_flush()
+{
+    vec_free(ftepp->output_string);
+}
+
+void ftepp_finish()
+{
+    if (!ftepp)
+        return;
+    ftepp_delete(ftepp);
+    ftepp = NULL;
+}