bool newline;
unsigned int errors;
+ bool output_on;
ppcondition *conditions;
ppmacro **macros;
+
+ bool output_string;
+ char *output;
} ftepp_t;
#define ftepp_tokval(f) ((f)->lex->tok.value)
va_end(ap);
}
-pptoken *pptoken_make(ftepp_t *ftepp)
+static pptoken *pptoken_make(ftepp_t *ftepp)
{
pptoken *token = (pptoken*)mem_a(sizeof(pptoken));
token->token = ftepp->token;
return token;
}
-void pptoken_delete(pptoken *self)
+static void pptoken_delete(pptoken *self)
{
mem_d(self->value);
mem_d(self);
}
-ppmacro *ppmacro_new(lex_ctx ctx, const char *name)
+static ppmacro *ppmacro_new(lex_ctx ctx, const char *name)
{
ppmacro *macro = (ppmacro*)mem_a(sizeof(ppmacro));
memset(macro, 0, sizeof(*macro));
return macro;
}
-void ppmacro_delete(ppmacro *self)
+static void ppmacro_delete(ppmacro *self)
{
size_t i;
for (i = 0; i < vec_size(self->params); ++i)
mem_d(self);
}
-ftepp_t* ftepp_init()
+static ftepp_t* ftepp_init()
{
ftepp_t *ftepp;
ftepp = (ftepp_t*)mem_a(sizeof(*ftepp));
memset(ftepp, 0, sizeof(*ftepp));
+ ftepp->output_on = true;
+
return ftepp;
}
-void ftepp_delete(ftepp_t *self)
+static void ftepp_delete(ftepp_t *self)
{
size_t i;
for (i = 0; i < vec_size(self->macros); ++i)
static void ftepp_out(ftepp_t *ftepp, const char *str, bool ignore_cond)
{
- if (ignore_cond ||
- !vec_size(ftepp->conditions) ||
- vec_last(ftepp->conditions).on)
+ if (ignore_cond || ftepp->output_on)
{
- printf("%s", str);
+ size_t len;
+ char *data;
+ if (!ftepp->output_string) {
+ printf("%s", str);
+ return;
+ }
+ len = strlen(str);
+ data = vec_add(ftepp->output, len);
+ memcpy(data, str, len);
}
}
-ppmacro* ftepp_macro_find(ftepp_t *ftepp, const char *name)
+static void ftepp_update_output_condition(ftepp_t *ftepp)
+{
+ size_t i;
+ ftepp->output_on = true;
+ for (i = 0; i < vec_size(ftepp->conditions); ++i)
+ ftepp->output_on = ftepp->output_on && ftepp->conditions[i].on;
+}
+
+static ppmacro* ftepp_macro_find(ftepp_t *ftepp, const char *name)
{
size_t i;
for (i = 0; i < vec_size(ftepp->macros); ++i) {
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;
}
return true;
}
+/**
+ * When a macro is used we have to handle parameters as well
+ * as special-concatenation via ## or stringification via #
+ *
+ * Note: parenthesis can nest, so FOO((a),b) is valid, but only
+ * this kind of parens. Curly braces or [] don't count towards the
+ * paren-level.
+ */
+typedef struct {
+ pptoken **tokens;
+} macroparam;
+
+static void macroparam_clean(macroparam *self)
+{
+ size_t i;
+ for (i = 0; i < vec_size(self->tokens); ++i)
+ pptoken_delete(self->tokens[i]);
+ vec_free(self->tokens);
+}
+
+/* need to leave the last token up */
+static bool ftepp_macro_call_params(ftepp_t *ftepp, macroparam **out_params)
+{
+ macroparam *params = NULL;
+ pptoken *ptok;
+ macroparam mp;
+ size_t parens = 0;
+ size_t i;
+
+ if (!ftepp_skipallwhite(ftepp))
+ return false;
+ while (ftepp->token != ')') {
+ mp.tokens = NULL;
+ if (!ftepp_skipallwhite(ftepp))
+ return false;
+ while (parens || ftepp->token != ',') {
+ if (ftepp->token == '(')
+ ++parens;
+ else if (ftepp->token == ')') {
+ if (!parens)
+ break;
+ --parens;
+ }
+ ptok = pptoken_make(ftepp);
+ vec_push(mp.tokens, ptok);
+ if (ftepp_next(ftepp) >= TOKEN_EOF) {
+ ftepp_error(ftepp, "unexpected EOF in macro call");
+ goto on_error;
+ }
+ }
+ vec_push(params, mp);
+ mp.tokens = NULL;
+ if (ftepp->token == ')')
+ break;
+ if (ftepp->token != ',') {
+ ftepp_error(ftepp, "expected closing paren or comma in macro call");
+ goto on_error;
+ }
+ if (ftepp_next(ftepp) >= TOKEN_EOF) {
+ ftepp_error(ftepp, "unexpected EOF 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;
+
+on_error:
+ if (mp.tokens)
+ macroparam_clean(&mp);
+ for (i = 0; i < vec_size(params); ++i)
+ macroparam_clean(¶ms[i]);
+ vec_free(params);
+ return false;
+}
+
+static bool macro_params_find(ppmacro *macro, const char *name, size_t *idx)
+{
+ size_t i;
+ for (i = 0; i < vec_size(macro->params); ++i) {
+ if (!strcmp(macro->params[i], name)) {
+ *idx = i;
+ return true;
+ }
+ }
+ return 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;
+ lex_file *old_lexer = ftepp->lex;
+ bool retval = true;
+
+ size_t o, pi, pv;
+ lex_file *inlex;
+
+ /* really ... */
+ if (!vec_size(macro->output))
+ return true;
+
+ ftepp->output = NULL;
+ ftepp->output_string = true;
+ for (o = 0; o < vec_size(macro->output); ++o) {
+ pptoken *out = macro->output[o];
+ switch (out->token) {
+ 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);
+ }
+ }
+ break;
+ case TOKEN_EOL:
+ ftepp_out(ftepp, "\n", false);
+ break;
+ default:
+ ftepp_out(ftepp, out->value, false);
+ break;
+ }
+ }
+ vec_push(ftepp->output, 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);
+ 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->lex = inlex;
+ if (!ftepp_preprocess(ftepp)) {
+ retval = false;
+ goto cleanup;
+ }
+
+cleanup:
+ ftepp->lex = old_lexer;
+ ftepp->output = old_string;
+ ftepp->output_string = old_string_flag;
+ return retval;
+}
+
static bool ftepp_macro_call(ftepp_t *ftepp, ppmacro *macro)
{
- size_t o;
- ftepp_next(ftepp);
+ size_t o;
+ macroparam *params = NULL;
+ bool retval = true;
if (!macro->has_params) {
- for (o = 0; o < vec_size(macro->output); ++o) {
- ftepp_out(ftepp, macro->output[o]->value, false);
- }
+ if (!ftepp_macro_expand(ftepp, macro, NULL))
+ return false;
+ ftepp_next(ftepp);
return true;
}
+ ftepp_next(ftepp);
if (!ftepp_skipallwhite(ftepp))
return false;
- return true;
-}
-/**
- * When a macro is used we have to handle parameters as well
- * as special-concatenation via ## or stringification via #
- */
+ if (ftepp->token != '(') {
+ ftepp_error(ftepp, "expected macro parameters in parenthesis");
+ return false;
+ }
+
+ ftepp_next(ftepp);
+ 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,
+ (unsigned int)vec_size(macro->params),
+ (unsigned int)vec_size(params));
+ retval = false;
+ goto cleanup;
+ }
+
+ if (!ftepp_macro_expand(ftepp, macro, params))
+ retval = false;
+ ftepp_next(ftepp);
+
+cleanup:
+ for (o = 0; o < vec_size(params); ++o)
+ macroparam_clean(¶ms[o]);
+ vec_free(params);
+ return retval;
+}
/**
* #if - the FTEQCC way:
return false;
cond.was_on = cond.on;
vec_push(ftepp->conditions, cond);
+ ftepp->output_on = ftepp->output_on && cond.on;
break;
}
else if (!strcmp(ftepp_tokval(ftepp), "ifndef")) {
cond.on = !cond.on;
cond.was_on = cond.on;
vec_push(ftepp->conditions, cond);
+ ftepp->output_on = ftepp->output_on && cond.on;
break;
}
else if (!strcmp(ftepp_tokval(ftepp), "elifdef")) {
pc = &vec_last(ftepp->conditions);
pc->on = !pc->was_on && cond.on;
pc->was_on = pc->was_on || pc->on;
+ ftepp_update_output_condition(ftepp);
break;
}
else if (!strcmp(ftepp_tokval(ftepp), "elifndef")) {
pc = &vec_last(ftepp->conditions);
pc->on = !pc->was_on && cond.on;
pc->was_on = pc->was_on || pc->on;
+ ftepp_update_output_condition(ftepp);
break;
}
else if (!strcmp(ftepp_tokval(ftepp), "elif")) {
pc = &vec_last(ftepp->conditions);
pc->on = !pc->was_on && cond.on;
pc->was_on = pc->was_on || pc->on;
+ ftepp_update_output_condition(ftepp);
break;
}
else if (!strcmp(ftepp_tokval(ftepp), "if")) {
return false;
cond.was_on = cond.on;
vec_push(ftepp->conditions, cond);
+ ftepp->output_on = ftepp->output_on && cond.on;
break;
}
else if (!strcmp(ftepp_tokval(ftepp), "else")) {
pc->on = !pc->was_on;
pc->had_else = true;
ftepp_next(ftepp);
+ ftepp_update_output_condition(ftepp);
break;
}
else if (!strcmp(ftepp_tokval(ftepp), "endif")) {
}
vec_pop(ftepp->conditions);
ftepp_next(ftepp);
+ ftepp_update_output_condition(ftepp);
break;
}
else {
case TOKEN_EOF:
ftepp_error(ftepp, "missing newline at end of file", ftepp_tokval(ftepp));
return false;
+
+ /* Builtins! Don't forget the builtins! */
+ case TOKEN_INTCONST:
+ case TOKEN_FLOATCONST:
+ ftepp_out(ftepp, "#", false);
+ return true;
}
if (!ftepp_skipspace(ftepp))
return false;
{
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;
+#endif
switch (ftepp->token) {
case TOKEN_KEYWORD:
} while (!ftepp->errors && ftepp->token < TOKEN_EOF);
newline = ftepp->token == TOKEN_EOF;
- ftepp_delete(ftepp);
return newline;
}
con_out("failed to open file \"%s\"\n", filename);
return false;
}
- return ftepp_preprocess(ftepp);
+ if (!ftepp_preprocess(ftepp)) {
+ ftepp_delete(ftepp);
+ return false;
+ }
+ ftepp_delete(ftepp);
+ return true;
}
bool ftepp_preprocess_string(const char *name, const char *str)
con_out("failed to create lexer for string \"%s\"\n", name);
return false;
}
- return ftepp_preprocess(ftepp);
+ if (!ftepp_preprocess(ftepp)) {
+ ftepp_delete(ftepp);
+ return false;
+ }
+ ftepp_delete(ftepp);
+ return true;
}
projects / xonotic / gmqcc.git / blobdiff