2 * Copyright (C) 2012, 2013
6 * Permission is hereby granted, free of charge, to any person obtaining a copy of
7 * this software and associated documentation files (the "Software"), to deal in
8 * the Software without restriction, including without limitation the rights to
9 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
10 * of the Software, and to permit persons to whom the Software is furnished to do
11 * so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
37 /* a copy from the lexer */
51 /* yes we need an extra flag since `#define FOO x` is not the same as `#define FOO() x` */
64 ppcondition *conditions;
75 * Implement the predef subsystem now. We can do this safely with the
76 * help of lexer contexts.
78 static uint32_t ftepp_predef_countval = 0;
79 static uint32_t ftepp_predef_randval = 0;
82 char *ftepp_predef_date(lex_file *context) {
85 char *value = mem_a(82);
86 /* 82 is enough for strftime but we also have " " in our string */
92 itime = localtime(&rtime);
94 strftime(value, 82, "\"%b %d %Y\"", itime);
100 char *ftepp_predef_time(lex_file *context) {
103 char *value = mem_a(82);
104 /* 82 is enough for strftime but we also have " " in our string */
110 itime = localtime(&rtime);
112 strftime(value, 82, "\"%X\"", itime);
118 char *ftepp_predef_line(lex_file *context) {
120 util_asprintf(&value, "%d", (int)context->line);
124 char *ftepp_predef_file(lex_file *context) {
125 size_t length = strlen(context->name) + 3; /* two quotes and a terminator */
126 char *value = (char*)mem_a(length);
127 memset (value, 0, length);
128 sprintf(value, "\"%s\"", context->name);
132 /* __COUNTER_LAST__ */
133 char *ftepp_predef_counterlast(lex_file *context) {
135 util_asprintf(&value, "%u", ftepp_predef_countval);
141 char *ftepp_predef_counter(lex_file *context) {
143 ftepp_predef_countval ++;
144 util_asprintf(&value, "%u", ftepp_predef_countval);
150 char *ftepp_predef_random(lex_file *context) {
152 ftepp_predef_randval = (util_rand() % 0xFF) + 1;
153 util_asprintf(&value, "%u", ftepp_predef_randval);
158 /* __RANDOM_LAST__ */
159 char *ftepp_predef_randomlast(lex_file *context) {
161 util_asprintf(&value, "%u", ftepp_predef_randval);
167 const ftepp_predef_t ftepp_predefs[FTEPP_PREDEF_COUNT] = {
168 { "__LINE__", &ftepp_predef_line },
169 { "__FILE__", &ftepp_predef_file },
170 { "__COUNTER__", &ftepp_predef_counter },
171 { "__COUNTER_LAST__", &ftepp_predef_counterlast },
172 { "__RANDOM__", &ftepp_predef_random },
173 { "__RANDOM_LAST__", &ftepp_predef_randomlast },
174 { "__DATE__", &ftepp_predef_date },
175 { "__TIME__", &ftepp_predef_time }
178 #define ftepp_tokval(f) ((f)->lex->tok.value)
179 #define ftepp_ctx(f) ((f)->lex->tok.ctx)
181 static void ftepp_errorat(ftepp_t *ftepp, lex_ctx ctx, const char *fmt, ...)
188 con_cvprintmsg((void*)&ctx, LVL_ERROR, "error", fmt, ap);
192 static void ftepp_error(ftepp_t *ftepp, const char *fmt, ...)
199 con_cvprintmsg((void*)&ftepp->lex->tok.ctx, LVL_ERROR, "error", fmt, ap);
203 static bool GMQCC_WARN ftepp_warn(ftepp_t *ftepp, int warntype, const char *fmt, ...)
209 r = vcompile_warning(ftepp->lex->tok.ctx, warntype, fmt, ap);
214 static pptoken *pptoken_make(ftepp_t *ftepp)
216 pptoken *token = (pptoken*)mem_a(sizeof(pptoken));
217 token->token = ftepp->token;
219 if (token->token == TOKEN_WHITE)
220 token->value = util_strdup(" ");
223 token->value = util_strdup(ftepp_tokval(ftepp));
225 memcpy(&token->constval, &ftepp->lex->tok.constval, sizeof(token->constval));
229 static void pptoken_delete(pptoken *self)
235 static ppmacro *ppmacro_new(lex_ctx ctx, const char *name)
237 ppmacro *macro = (ppmacro*)mem_a(sizeof(ppmacro));
240 memset(macro, 0, sizeof(*macro));
241 macro->name = util_strdup(name);
245 static void ppmacro_delete(ppmacro *self)
248 for (i = 0; i < vec_size(self->params); ++i)
249 mem_d(self->params[i]);
250 vec_free(self->params);
251 for (i = 0; i < vec_size(self->output); ++i)
252 pptoken_delete(self->output[i]);
253 vec_free(self->output);
258 static ftepp_t* ftepp_new()
262 ftepp = (ftepp_t*)mem_a(sizeof(*ftepp));
263 memset(ftepp, 0, sizeof(*ftepp));
265 ftepp->output_on = true;
270 static void ftepp_flush_do(ftepp_t *self)
272 vec_free(self->output_string);
275 static void ftepp_delete(ftepp_t *self)
278 ftepp_flush_do(self);
280 mem_d(self->itemname);
281 if (self->includename)
282 vec_free(self->includename);
283 for (i = 0; i < vec_size(self->macros); ++i)
284 ppmacro_delete(self->macros[i]);
285 vec_free(self->macros);
286 vec_free(self->conditions);
288 lex_close(self->lex);
292 static void ftepp_out(ftepp_t *ftepp, const char *str, bool ignore_cond)
294 if (ignore_cond || ftepp->output_on)
299 data = vec_add(ftepp->output_string, len);
300 memcpy(data, str, len);
304 static void ftepp_update_output_condition(ftepp_t *ftepp)
307 ftepp->output_on = true;
308 for (i = 0; i < vec_size(ftepp->conditions); ++i)
309 ftepp->output_on = ftepp->output_on && ftepp->conditions[i].on;
312 static ppmacro* ftepp_macro_find(ftepp_t *ftepp, const char *name)
315 for (i = 0; i < vec_size(ftepp->macros); ++i) {
316 if (!strcmp(name, ftepp->macros[i]->name))
317 return ftepp->macros[i];
322 static void ftepp_macro_delete(ftepp_t *ftepp, const char *name)
325 for (i = 0; i < vec_size(ftepp->macros); ++i) {
326 if (!strcmp(name, ftepp->macros[i]->name)) {
327 vec_remove(ftepp->macros, i, 1);
333 static GMQCC_INLINE int ftepp_next(ftepp_t *ftepp)
335 return (ftepp->token = lex_do(ftepp->lex));
338 /* Important: this does not skip newlines! */
339 static bool ftepp_skipspace(ftepp_t *ftepp)
341 if (ftepp->token != TOKEN_WHITE)
343 while (ftepp_next(ftepp) == TOKEN_WHITE) {}
344 if (ftepp->token >= TOKEN_EOF) {
345 ftepp_error(ftepp, "unexpected end of preprocessor directive");
351 /* this one skips EOLs as well */
352 static bool ftepp_skipallwhite(ftepp_t *ftepp)
354 if (ftepp->token != TOKEN_WHITE && ftepp->token != TOKEN_EOL)
358 } while (ftepp->token == TOKEN_WHITE || ftepp->token == TOKEN_EOL);
359 if (ftepp->token >= TOKEN_EOF) {
360 ftepp_error(ftepp, "unexpected end of preprocessor directive");
367 * The huge macro parsing code...
369 static bool ftepp_define_params(ftepp_t *ftepp, ppmacro *macro)
373 if (!ftepp_skipspace(ftepp))
375 if (ftepp->token == ')')
377 switch (ftepp->token) {
381 vec_push(macro->params, util_strdup(ftepp_tokval(ftepp)));
384 macro->variadic = true;
387 ftepp_error(ftepp, "unexpected token in parameter list");
391 if (!ftepp_skipspace(ftepp))
393 if (macro->variadic && ftepp->token != ')') {
394 ftepp_error(ftepp, "cannot have parameters after the variadic parameters");
397 } while (ftepp->token == ',');
398 if (ftepp->token != ')') {
399 ftepp_error(ftepp, "expected closing paren after macro parameter list");
403 /* skipspace happens in ftepp_define */
407 static bool ftepp_define_body(ftepp_t *ftepp, ppmacro *macro)
410 while (ftepp->token != TOKEN_EOL && ftepp->token < TOKEN_EOF) {
411 bool subscript = false;
413 if (macro->variadic && !strcmp(ftepp_tokval(ftepp), "__VA_ARGS__")) {
414 /* remember the token */
415 if (ftepp_next(ftepp) == '#') {
419 if (subscript && ftepp_next(ftepp) != '#') {
420 ftepp_error(ftepp, "expected `##` in __VA_ARGS__ for subscripting");
422 } else if (subscript && ftepp_next(ftepp) == '[') {
423 if (ftepp_next(ftepp) != TOKEN_INTCONST) {
424 ftepp_error(ftepp, "expected index for __VA_ARGS__ subscript");
428 index = atoi(ftepp_tokval(ftepp));
430 if (ftepp_next(ftepp) != ']') {
431 ftepp_error(ftepp, "expected `]` in __VA_ARGS__ subscript");
436 * mark it as an array to be handled later as such and not
437 * as traditional __VA_ARGS__
439 ftepp->token = TOKEN_VA_ARGS_ARRAY;
440 ptok = pptoken_make(ftepp);
441 ptok->constval.i = index;
442 vec_push(macro->output, ptok);
445 int old = ftepp->token;
446 ftepp->token = TOKEN_VA_ARGS;
447 ptok = pptoken_make(ftepp);
448 vec_push(macro->output, ptok);
454 ptok = pptoken_make(ftepp);
455 vec_push(macro->output, ptok);
459 /* recursive expansion can cause EOFs here */
460 if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
461 ftepp_error(ftepp, "unexpected junk after macro or unexpected end of file");
467 static bool ftepp_define(ftepp_t *ftepp)
470 size_t l = ftepp_ctx(ftepp).line;
472 (void)ftepp_next(ftepp);
473 if (!ftepp_skipspace(ftepp))
476 switch (ftepp->token) {
480 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
481 if (macro && ftepp->output_on) {
482 if (ftepp_warn(ftepp, WARN_PREPROCESSOR, "redefining `%s`", ftepp_tokval(ftepp)))
484 ftepp_macro_delete(ftepp, ftepp_tokval(ftepp));
486 macro = ppmacro_new(ftepp_ctx(ftepp), ftepp_tokval(ftepp));
489 ftepp_error(ftepp, "expected macro name");
493 (void)ftepp_next(ftepp);
495 if (ftepp->token == '(') {
496 macro->has_params = true;
497 if (!ftepp_define_params(ftepp, macro))
501 if (!ftepp_skipspace(ftepp))
504 if (!ftepp_define_body(ftepp, macro))
507 if (ftepp->output_on)
508 vec_push(ftepp->macros, macro);
510 ppmacro_delete(macro);
513 for (; l < ftepp_ctx(ftepp).line; ++l)
514 ftepp_out(ftepp, "\n", true);
519 * When a macro is used we have to handle parameters as well
520 * as special-concatenation via ## or stringification via #
522 * Note: parenthesis can nest, so FOO((a),b) is valid, but only
523 * this kind of parens. Curly braces or [] don't count towards the
530 static void macroparam_clean(macroparam *self)
533 for (i = 0; i < vec_size(self->tokens); ++i)
534 pptoken_delete(self->tokens[i]);
535 vec_free(self->tokens);
538 /* need to leave the last token up */
539 static bool ftepp_macro_call_params(ftepp_t *ftepp, macroparam **out_params)
541 macroparam *params = NULL;
547 if (!ftepp_skipallwhite(ftepp))
549 while (ftepp->token != ')') {
551 if (!ftepp_skipallwhite(ftepp))
553 while (parens || ftepp->token != ',') {
554 if (ftepp->token == '(')
556 else if (ftepp->token == ')') {
561 ptok = pptoken_make(ftepp);
562 vec_push(mp.tokens, ptok);
563 if (ftepp_next(ftepp) >= TOKEN_EOF) {
564 ftepp_error(ftepp, "unexpected EOF in macro call");
568 vec_push(params, mp);
570 if (ftepp->token == ')')
572 if (ftepp->token != ',') {
573 ftepp_error(ftepp, "expected closing paren or comma in macro call");
576 if (ftepp_next(ftepp) >= TOKEN_EOF) {
577 ftepp_error(ftepp, "unexpected EOF in macro call");
581 /* need to leave that up
582 if (ftepp_next(ftepp) >= TOKEN_EOF) {
583 ftepp_error(ftepp, "unexpected EOF in macro call");
587 *out_params = params;
592 macroparam_clean(&mp);
593 for (i = 0; i < vec_size(params); ++i)
594 macroparam_clean(¶ms[i]);
599 static bool macro_params_find(ppmacro *macro, const char *name, size_t *idx)
602 for (i = 0; i < vec_size(macro->params); ++i) {
603 if (!strcmp(macro->params[i], name)) {
611 static void ftepp_stringify_token(ftepp_t *ftepp, pptoken *token)
616 switch (token->token) {
617 case TOKEN_STRINGCONST:
620 /* in preprocessor mode strings already are string,
621 * so we don't get actual newline bytes here.
622 * Still need to escape backslashes and quotes.
625 case '\\': ftepp_out(ftepp, "\\\\", false); break;
626 case '"': ftepp_out(ftepp, "\\\"", false); break;
629 ftepp_out(ftepp, chs, false);
636 ftepp_out(ftepp, " ", false);
639 ftepp_out(ftepp, "\\n", false);
642 ftepp_out(ftepp, token->value, false);
647 static void ftepp_stringify(ftepp_t *ftepp, macroparam *param)
650 ftepp_out(ftepp, "\"", false);
651 for (i = 0; i < vec_size(param->tokens); ++i)
652 ftepp_stringify_token(ftepp, param->tokens[i]);
653 ftepp_out(ftepp, "\"", false);
656 static void ftepp_recursion_header(ftepp_t *ftepp)
658 ftepp_out(ftepp, "\n#pragma push(line)\n", false);
661 static void ftepp_recursion_footer(ftepp_t *ftepp)
663 ftepp_out(ftepp, "\n#pragma pop(line)\n", false);
666 static void ftepp_param_out(ftepp_t *ftepp, macroparam *param)
670 for (i = 0; i < vec_size(param->tokens); ++i) {
671 out = param->tokens[i];
672 if (out->token == TOKEN_EOL)
673 ftepp_out(ftepp, "\n", false);
675 ftepp_out(ftepp, out->value, false);
679 static bool ftepp_preprocess(ftepp_t *ftepp);
680 static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *params, bool resetline)
682 char *old_string = ftepp->output_string;
684 lex_file *old_lexer = ftepp->lex;
685 size_t vararg_start = vec_size(macro->params);
697 if (vararg_start < vec_size(params))
698 varargs = vec_size(params) - vararg_start;
703 if (!vec_size(macro->output))
706 ftepp->output_string = NULL;
707 for (o = 0; o < vec_size(macro->output); ++o) {
708 pptoken *out = macro->output[o];
709 switch (out->token) {
711 if (!macro->variadic) {
712 ftepp_error(ftepp, "internal preprocessor error: TOKEN_VA_ARGS in non-variadic macro");
713 vec_free(old_string);
720 ftepp_param_out(ftepp, ¶ms[pi + vararg_start]);
721 for (++pi; pi < varargs; ++pi) {
722 ftepp_out(ftepp, ", ", false);
723 ftepp_param_out(ftepp, ¶ms[pi + vararg_start]);
727 case TOKEN_VA_ARGS_ARRAY:
728 if ((size_t)out->constval.i >= varargs) {
729 ftepp_error(ftepp, "subscript of `[%u]` is out of bounds for `__VA_ARGS__`", out->constval.i);
730 vec_free(old_string);
734 ftepp_param_out(ftepp, ¶ms[out->constval.i + vararg_start]);
740 if (!macro_params_find(macro, out->value, &pi)) {
741 ftepp_out(ftepp, out->value, false);
744 ftepp_param_out(ftepp, ¶ms[pi]);
747 if (o + 1 < vec_size(macro->output)) {
748 nextok = macro->output[o+1]->token;
750 /* raw concatenation */
754 if ( (nextok == TOKEN_IDENT ||
755 nextok == TOKEN_KEYWORD ||
756 nextok == TOKEN_TYPENAME) &&
757 macro_params_find(macro, macro->output[o+1]->value, &pi))
760 ftepp_stringify(ftepp, ¶ms[pi]);
764 ftepp_out(ftepp, "#", false);
767 ftepp_out(ftepp, "\n", false);
770 ftepp_out(ftepp, out->value, false);
774 vec_push(ftepp->output_string, 0);
775 /* Now run the preprocessor recursively on this string buffer */
777 printf("__________\n%s\n=========\n", ftepp->output_string);
779 inlex = lex_open_string(ftepp->output_string, vec_size(ftepp->output_string)-1, ftepp->lex->name);
781 ftepp_error(ftepp, "internal error: failed to instantiate lexer");
786 inlex->line = ftepp->lex->line;
787 inlex->sline = ftepp->lex->sline;
790 old_inmacro = ftepp->in_macro;
791 ftepp->in_macro = true;
792 ftepp->output_string = NULL;
793 if (!ftepp_preprocess(ftepp)) {
794 ftepp->in_macro = old_inmacro;
795 vec_free(ftepp->lex->open_string);
796 vec_free(ftepp->output_string);
797 lex_close(ftepp->lex);
801 ftepp->in_macro = old_inmacro;
802 vec_free(ftepp->lex->open_string);
803 lex_close(ftepp->lex);
805 inner_string = ftepp->output_string;
806 ftepp->output_string = old_string;
808 has_newlines = (strchr(inner_string, '\n') != NULL);
810 if (has_newlines && !old_inmacro)
811 ftepp_recursion_header(ftepp);
813 vec_append(ftepp->output_string, vec_size(inner_string), inner_string);
814 vec_free(inner_string);
816 if (has_newlines && !old_inmacro)
817 ftepp_recursion_footer(ftepp);
819 if (resetline && !ftepp->in_macro) {
821 sprintf(lineno, "\n#pragma line(%lu)\n", (unsigned long)(old_lexer->sline));
822 ftepp_out(ftepp, lineno, false);
825 old_string = ftepp->output_string;
827 ftepp->lex = old_lexer;
828 ftepp->output_string = old_string;
832 static bool ftepp_macro_call(ftepp_t *ftepp, ppmacro *macro)
835 macroparam *params = NULL;
839 if (!macro->has_params) {
840 if (!ftepp_macro_expand(ftepp, macro, NULL, false))
847 if (!ftepp_skipallwhite(ftepp))
850 if (ftepp->token != '(') {
851 ftepp_error(ftepp, "expected macro parameters in parenthesis");
856 paramline = ftepp->lex->sline;
857 if (!ftepp_macro_call_params(ftepp, ¶ms))
860 if ( vec_size(params) < vec_size(macro->params) ||
861 (vec_size(params) > vec_size(macro->params) && !macro->variadic) )
863 ftepp_error(ftepp, "macro %s expects%s %u paramteters, %u provided", macro->name,
864 (macro->variadic ? " at least" : ""),
865 (unsigned int)vec_size(macro->params),
866 (unsigned int)vec_size(params));
871 if (!ftepp_macro_expand(ftepp, macro, params, (paramline != ftepp->lex->sline)))
876 for (o = 0; o < vec_size(params); ++o)
877 macroparam_clean(¶ms[o]);
883 * #if - the FTEQCC way:
884 * defined(FOO) => true if FOO was #defined regardless of parameters or contents
885 * <numbers> => True if the number is not 0
886 * !<factor> => True if the factor yields false
887 * !!<factor> => ERROR on 2 or more unary nots
888 * <macro> => becomes the macro's FIRST token regardless of parameters
889 * <e> && <e> => True if both expressions are true
890 * <e> || <e> => True if either expression is true
892 * <ident> => False (remember for macros the <macro> rule applies instead)
893 * Unary + and - are weird and wrong in fteqcc so we don't allow them
894 * parenthesis in expressions are allowed
895 * parameter lists on macros are errors
896 * No mathematical calculations are executed
898 static bool ftepp_if_expr(ftepp_t *ftepp, bool *out, double *value_out);
899 static bool ftepp_if_op(ftepp_t *ftepp)
901 ftepp->lex->flags.noops = false;
903 if (!ftepp_skipspace(ftepp))
905 ftepp->lex->flags.noops = true;
908 static bool ftepp_if_value(ftepp_t *ftepp, bool *out, double *value_out)
914 if (!ftepp_skipspace(ftepp))
917 while (ftepp->token == '!') {
920 if (!ftepp_skipspace(ftepp))
924 if (ftepp->token == TOKEN_OPERATOR && !strcmp(ftepp_tokval(ftepp), "-"))
928 if (!ftepp_skipspace(ftepp))
932 switch (ftepp->token) {
936 if (!strcmp(ftepp_tokval(ftepp), "defined")) {
938 if (!ftepp_skipspace(ftepp))
940 if (ftepp->token != '(') {
941 ftepp_error(ftepp, "`defined` keyword in #if requires a macro name in parenthesis");
945 if (!ftepp_skipspace(ftepp))
947 if (ftepp->token != TOKEN_IDENT &&
948 ftepp->token != TOKEN_TYPENAME &&
949 ftepp->token != TOKEN_KEYWORD)
951 ftepp_error(ftepp, "defined() used on an unexpected token type");
954 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
957 if (!ftepp_skipspace(ftepp))
959 if (ftepp->token != ')') {
960 ftepp_error(ftepp, "expected closing paren");
966 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
967 if (!macro || !vec_size(macro->output)) {
971 /* This does not expand recursively! */
972 switch (macro->output[0]->token) {
974 *value_out = macro->output[0]->constval.i;
975 *out = !!(macro->output[0]->constval.i);
977 case TOKEN_FLOATCONST:
978 *value_out = macro->output[0]->constval.f;
979 *out = !!(macro->output[0]->constval.f);
987 case TOKEN_STRINGCONST:
992 *value_out = ftepp->lex->tok.constval.i;
993 *out = !!(ftepp->lex->tok.constval.i);
995 case TOKEN_FLOATCONST:
996 *value_out = ftepp->lex->tok.constval.f;
997 *out = !!(ftepp->lex->tok.constval.f);
1002 if (!ftepp_if_expr(ftepp, out, value_out))
1004 if (ftepp->token != ')') {
1005 ftepp_error(ftepp, "expected closing paren in #if expression");
1011 ftepp_error(ftepp, "junk in #if: `%s` ...", ftepp_tokval(ftepp));
1013 ftepp_error(ftepp, "internal: token %i\n", ftepp->token);
1017 *value_out = -*value_out;
1020 *value_out = (*out ? 1 : 0);
1026 static bool ftepp_if_nextvalue(ftepp_t *ftepp, bool *out, double *value_out)
1028 if (!ftepp_next(ftepp))
1030 return ftepp_if_value(ftepp, out, value_out);
1034 static bool ftepp_if_expr(ftepp_t *ftepp, bool *out, double *value_out)
1036 if (!ftepp_if_value(ftepp, out, value_out))
1039 if (!ftepp_if_op(ftepp))
1042 if (ftepp->token == ')' || ftepp->token != TOKEN_OPERATOR)
1045 /* FTEQCC is all right-associative and no precedence here */
1046 if (!strcmp(ftepp_tokval(ftepp), "&&") ||
1047 !strcmp(ftepp_tokval(ftepp), "||"))
1050 char opc = ftepp_tokval(ftepp)[0];
1054 if (!ftepp_next(ftepp))
1056 if (!ftepp_if_expr(ftepp, &next, &nextvalue))
1060 *out = *out && next;
1062 *out = *out || next;
1064 *value_out = (*out ? 1 : 0);
1067 else if (!strcmp(ftepp_tokval(ftepp), "==") ||
1068 !strcmp(ftepp_tokval(ftepp), "!=") ||
1069 !strcmp(ftepp_tokval(ftepp), ">=") ||
1070 !strcmp(ftepp_tokval(ftepp), "<=") ||
1071 !strcmp(ftepp_tokval(ftepp), ">") ||
1072 !strcmp(ftepp_tokval(ftepp), "<"))
1075 const char opc0 = ftepp_tokval(ftepp)[0];
1076 const char opc1 = ftepp_tokval(ftepp)[1];
1079 if (!ftepp_next(ftepp))
1081 if (!ftepp_if_expr(ftepp, &next, &other))
1085 *out = (*value_out == other);
1086 else if (opc0 == '!')
1087 *out = (*value_out != other);
1088 else if (opc0 == '>') {
1089 if (opc1 == '=') *out = (*value_out >= other);
1090 else *out = (*value_out > other);
1092 else if (opc0 == '<') {
1093 if (opc1 == '=') *out = (*value_out <= other);
1094 else *out = (*value_out < other);
1096 *value_out = (*out ? 1 : 0);
1101 ftepp_error(ftepp, "junk after #if");
1106 static bool ftepp_if(ftepp_t *ftepp, ppcondition *cond)
1108 bool result = false;
1111 memset(cond, 0, sizeof(*cond));
1112 (void)ftepp_next(ftepp);
1114 if (!ftepp_skipspace(ftepp))
1116 if (ftepp->token == TOKEN_EOL) {
1117 ftepp_error(ftepp, "expected expression for #if-directive");
1121 if (!ftepp_if_expr(ftepp, &result, &dummy))
1129 * ifdef is rather simple
1131 static bool ftepp_ifdef(ftepp_t *ftepp, ppcondition *cond)
1134 memset(cond, 0, sizeof(*cond));
1135 (void)ftepp_next(ftepp);
1136 if (!ftepp_skipspace(ftepp))
1139 switch (ftepp->token) {
1141 case TOKEN_TYPENAME:
1143 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
1146 ftepp_error(ftepp, "expected macro name");
1150 (void)ftepp_next(ftepp);
1151 if (!ftepp_skipspace(ftepp))
1153 /* relaxing this condition
1154 if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
1155 ftepp_error(ftepp, "stray tokens after #ifdef");
1164 * undef is also simple
1166 static bool ftepp_undef(ftepp_t *ftepp)
1168 (void)ftepp_next(ftepp);
1169 if (!ftepp_skipspace(ftepp))
1172 if (ftepp->output_on) {
1173 switch (ftepp->token) {
1175 case TOKEN_TYPENAME:
1177 ftepp_macro_delete(ftepp, ftepp_tokval(ftepp));
1180 ftepp_error(ftepp, "expected macro name");
1185 (void)ftepp_next(ftepp);
1186 if (!ftepp_skipspace(ftepp))
1188 /* relaxing this condition
1189 if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
1190 ftepp_error(ftepp, "stray tokens after #ifdef");
1197 /* Special unescape-string function which skips a leading quote
1198 * and stops at a quote, not just at \0
1200 static void unescape(const char *str, char *out) {
1202 while (*str && *str != '"') {
1206 case '\\': *out++ = *str; break;
1207 case '"': *out++ = *str; break;
1208 case 'a': *out++ = '\a'; break;
1209 case 'b': *out++ = '\b'; break;
1210 case 'r': *out++ = '\r'; break;
1211 case 'n': *out++ = '\n'; break;
1212 case 't': *out++ = '\t'; break;
1213 case 'f': *out++ = '\f'; break;
1214 case 'v': *out++ = '\v'; break;
1229 static char *ftepp_include_find_path(const char *file, const char *pathfile)
1232 char *filename = NULL;
1233 const char *last_slash;
1239 last_slash = strrchr(pathfile, '/');
1242 len = last_slash - pathfile;
1243 memcpy(vec_add(filename, len), pathfile, len);
1244 vec_push(filename, '/');
1248 memcpy(vec_add(filename, len+1), file, len);
1249 vec_last(filename) = 0;
1251 fp = file_open(filename, "rb");
1260 static char *ftepp_include_find(ftepp_t *ftepp, const char *file)
1262 char *filename = NULL;
1264 filename = ftepp_include_find_path(file, ftepp->includename);
1266 filename = ftepp_include_find_path(file, ftepp->itemname);
1270 static bool ftepp_directive_warning(ftepp_t *ftepp) {
1271 char *message = NULL;
1273 if (!ftepp_skipspace(ftepp))
1276 /* handle the odd non string constant case so it works like C */
1277 if (ftepp->token != TOKEN_STRINGCONST) {
1279 vec_upload(message, "#warning", 8);
1281 while (ftepp->token != TOKEN_EOL) {
1282 vec_upload(message, ftepp_tokval(ftepp), strlen(ftepp_tokval(ftepp)));
1285 vec_push(message, '\0');
1286 store = ftepp_warn(ftepp, WARN_CPP, message);
1291 unescape (ftepp_tokval(ftepp), ftepp_tokval(ftepp));
1292 return ftepp_warn(ftepp, WARN_CPP, "#warning %s", ftepp_tokval(ftepp));
1295 static void ftepp_directive_error(ftepp_t *ftepp) {
1296 char *message = NULL;
1298 if (!ftepp_skipspace(ftepp))
1301 /* handle the odd non string constant case so it works like C */
1302 if (ftepp->token != TOKEN_STRINGCONST) {
1303 vec_upload(message, "#error", 6);
1305 while (ftepp->token != TOKEN_EOL) {
1306 vec_upload(message, ftepp_tokval(ftepp), strlen(ftepp_tokval(ftepp)));
1309 vec_push(message, '\0');
1310 ftepp_error(ftepp, message);
1315 unescape (ftepp_tokval(ftepp), ftepp_tokval(ftepp));
1316 ftepp_error(ftepp, "#error %s", ftepp_tokval(ftepp));
1321 * FIXME: do we need/want a -I option?
1322 * FIXME: what about when dealing with files in subdirectories coming from a progs.src?
1324 static bool ftepp_include(ftepp_t *ftepp)
1326 lex_file *old_lexer = ftepp->lex;
1331 char *old_includename;
1333 (void)ftepp_next(ftepp);
1334 if (!ftepp_skipspace(ftepp))
1337 if (ftepp->token != TOKEN_STRINGCONST) {
1338 ftepp_error(ftepp, "expected filename to include");
1342 ctx = ftepp_ctx(ftepp);
1344 unescape(ftepp_tokval(ftepp), ftepp_tokval(ftepp));
1346 ftepp_out(ftepp, "\n#pragma file(", false);
1347 ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1348 ftepp_out(ftepp, ")\n#pragma line(1)\n", false);
1350 filename = ftepp_include_find(ftepp, ftepp_tokval(ftepp));
1352 ftepp_error(ftepp, "failed to open include file `%s`", ftepp_tokval(ftepp));
1355 inlex = lex_open(filename);
1357 ftepp_error(ftepp, "open failed on include file `%s`", filename);
1362 old_includename = ftepp->includename;
1363 ftepp->includename = filename;
1364 if (!ftepp_preprocess(ftepp)) {
1365 vec_free(ftepp->includename);
1366 ftepp->includename = old_includename;
1367 lex_close(ftepp->lex);
1368 ftepp->lex = old_lexer;
1371 vec_free(ftepp->includename);
1372 ftepp->includename = old_includename;
1373 lex_close(ftepp->lex);
1374 ftepp->lex = old_lexer;
1376 ftepp_out(ftepp, "\n#pragma file(", false);
1377 ftepp_out(ftepp, ctx.file, false);
1378 snprintf(lineno, sizeof(lineno), ")\n#pragma line(%lu)\n", (unsigned long)(ctx.line+1));
1379 ftepp_out(ftepp, lineno, false);
1382 (void)ftepp_next(ftepp);
1383 if (!ftepp_skipspace(ftepp))
1385 if (ftepp->token != TOKEN_EOL) {
1386 ftepp_error(ftepp, "stray tokens after #include");
1389 (void)ftepp_next(ftepp);
1394 /* Basic structure handlers */
1395 static bool ftepp_else_allowed(ftepp_t *ftepp)
1397 if (!vec_size(ftepp->conditions)) {
1398 ftepp_error(ftepp, "#else without #if");
1401 if (vec_last(ftepp->conditions).had_else) {
1402 ftepp_error(ftepp, "multiple #else for a single #if");
1408 static bool ftepp_hash(ftepp_t *ftepp)
1413 lex_ctx ctx = ftepp_ctx(ftepp);
1415 if (!ftepp_skipspace(ftepp))
1418 switch (ftepp->token) {
1421 case TOKEN_TYPENAME:
1422 if (!strcmp(ftepp_tokval(ftepp), "define")) {
1423 return ftepp_define(ftepp);
1425 else if (!strcmp(ftepp_tokval(ftepp), "undef")) {
1426 return ftepp_undef(ftepp);
1428 else if (!strcmp(ftepp_tokval(ftepp), "ifdef")) {
1429 if (!ftepp_ifdef(ftepp, &cond))
1431 cond.was_on = cond.on;
1432 vec_push(ftepp->conditions, cond);
1433 ftepp->output_on = ftepp->output_on && cond.on;
1436 else if (!strcmp(ftepp_tokval(ftepp), "ifndef")) {
1437 if (!ftepp_ifdef(ftepp, &cond))
1440 cond.was_on = cond.on;
1441 vec_push(ftepp->conditions, cond);
1442 ftepp->output_on = ftepp->output_on && cond.on;
1445 else if (!strcmp(ftepp_tokval(ftepp), "elifdef")) {
1446 if (!ftepp_else_allowed(ftepp))
1448 if (!ftepp_ifdef(ftepp, &cond))
1450 pc = &vec_last(ftepp->conditions);
1451 pc->on = !pc->was_on && cond.on;
1452 pc->was_on = pc->was_on || pc->on;
1453 ftepp_update_output_condition(ftepp);
1456 else if (!strcmp(ftepp_tokval(ftepp), "elifndef")) {
1457 if (!ftepp_else_allowed(ftepp))
1459 if (!ftepp_ifdef(ftepp, &cond))
1462 pc = &vec_last(ftepp->conditions);
1463 pc->on = !pc->was_on && cond.on;
1464 pc->was_on = pc->was_on || pc->on;
1465 ftepp_update_output_condition(ftepp);
1468 else if (!strcmp(ftepp_tokval(ftepp), "elif")) {
1469 if (!ftepp_else_allowed(ftepp))
1471 if (!ftepp_if(ftepp, &cond))
1473 pc = &vec_last(ftepp->conditions);
1474 pc->on = !pc->was_on && cond.on;
1475 pc->was_on = pc->was_on || pc->on;
1476 ftepp_update_output_condition(ftepp);
1479 else if (!strcmp(ftepp_tokval(ftepp), "if")) {
1480 if (!ftepp_if(ftepp, &cond))
1482 cond.was_on = cond.on;
1483 vec_push(ftepp->conditions, cond);
1484 ftepp->output_on = ftepp->output_on && cond.on;
1487 else if (!strcmp(ftepp_tokval(ftepp), "else")) {
1488 if (!ftepp_else_allowed(ftepp))
1490 pc = &vec_last(ftepp->conditions);
1491 pc->on = !pc->was_on;
1492 pc->had_else = true;
1494 ftepp_update_output_condition(ftepp);
1497 else if (!strcmp(ftepp_tokval(ftepp), "endif")) {
1498 if (!vec_size(ftepp->conditions)) {
1499 ftepp_error(ftepp, "#endif without #if");
1502 vec_pop(ftepp->conditions);
1504 ftepp_update_output_condition(ftepp);
1507 else if (!strcmp(ftepp_tokval(ftepp), "include")) {
1508 return ftepp_include(ftepp);
1510 else if (!strcmp(ftepp_tokval(ftepp), "pragma")) {
1511 ftepp_out(ftepp, "#", false);
1514 else if (!strcmp(ftepp_tokval(ftepp), "warning")) {
1515 ftepp_directive_warning(ftepp);
1518 else if (!strcmp(ftepp_tokval(ftepp), "error")) {
1519 ftepp_directive_error(ftepp);
1523 if (ftepp->output_on) {
1524 ftepp_error(ftepp, "unrecognized preprocessor directive: `%s`", ftepp_tokval(ftepp));
1531 /* break; never reached */
1533 ftepp_error(ftepp, "unexpected preprocessor token: `%s`", ftepp_tokval(ftepp));
1536 ftepp_errorat(ftepp, ctx, "empty preprocessor directive");
1539 ftepp_error(ftepp, "missing newline at end of file", ftepp_tokval(ftepp));
1542 /* Builtins! Don't forget the builtins! */
1543 case TOKEN_INTCONST:
1544 case TOKEN_FLOATCONST:
1545 ftepp_out(ftepp, "#", false);
1548 if (!ftepp_skipspace(ftepp))
1553 static bool ftepp_preprocess(ftepp_t *ftepp)
1556 bool newline = true;
1559 char *expand = NULL;
1562 ftepp->lex->flags.preprocessing = true;
1563 ftepp->lex->flags.mergelines = false;
1564 ftepp->lex->flags.noops = true;
1569 if (ftepp->token >= TOKEN_EOF)
1575 switch (ftepp->token) {
1578 case TOKEN_TYPENAME:
1579 /* is it a predef? */
1580 if (OPTS_FLAG(FTEPP_PREDEFS)) {
1581 for (i = 0; i < sizeof(ftepp_predefs) / sizeof (*ftepp_predefs); i++) {
1582 if (!strcmp(ftepp_predefs[i].name, ftepp_tokval(ftepp))) {
1583 expand = ftepp_predefs[i].func(ftepp->lex);
1584 ftepp_out(ftepp, expand, false);
1585 ftepp_next(ftepp); /* skip */
1587 mem_d(expand); /* free memory */
1593 if (ftepp->output_on)
1594 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
1599 ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1603 if (!ftepp_macro_call(ftepp, macro))
1604 ftepp->token = TOKEN_ERROR;
1608 ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1612 ftepp->lex->flags.mergelines = true;
1613 if (ftepp_next(ftepp) >= TOKEN_EOF) {
1614 ftepp_error(ftepp, "error in preprocessor directive");
1615 ftepp->token = TOKEN_ERROR;
1618 if (!ftepp_hash(ftepp))
1619 ftepp->token = TOKEN_ERROR;
1620 ftepp->lex->flags.mergelines = false;
1624 ftepp_out(ftepp, "\n", true);
1628 /* same as default but don't set newline=false */
1629 ftepp_out(ftepp, ftepp_tokval(ftepp), true);
1634 ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1638 } while (!ftepp->errors && ftepp->token < TOKEN_EOF);
1640 /* force a 0 at the end but don't count it as added to the output */
1641 vec_push(ftepp->output_string, 0);
1642 vec_shrinkby(ftepp->output_string, 1);
1644 return (ftepp->token == TOKEN_EOF);
1647 /* Like in parser.c - files keep the previous state so we have one global
1648 * preprocessor. Except here we will want to warn about dangling #ifs.
1650 static ftepp_t *ftepp;
1652 static bool ftepp_preprocess_done()
1655 if (vec_size(ftepp->conditions)) {
1656 if (ftepp_warn(ftepp, WARN_MULTIFILE_IF, "#if spanning multiple files, is this intended?"))
1659 lex_close(ftepp->lex);
1661 if (ftepp->itemname) {
1662 mem_d(ftepp->itemname);
1663 ftepp->itemname = NULL;
1668 bool ftepp_preprocess_file(const char *filename)
1670 ftepp->lex = lex_open(filename);
1671 ftepp->itemname = util_strdup(filename);
1673 con_out("failed to open file \"%s\"\n", filename);
1676 if (!ftepp_preprocess(ftepp))
1678 return ftepp_preprocess_done();
1681 bool ftepp_preprocess_string(const char *name, const char *str)
1683 ftepp->lex = lex_open_string(str, strlen(str), name);
1684 ftepp->itemname = util_strdup(name);
1686 con_out("failed to create lexer for string \"%s\"\n", name);
1689 if (!ftepp_preprocess(ftepp))
1691 return ftepp_preprocess_done();
1695 void ftepp_add_macro(const char *name, const char *value) {
1696 char *create = NULL;
1698 /* use saner path for empty macros */
1700 ftepp_add_define("__builtin__", name);
1704 vec_upload(create, "#define ", 8);
1705 vec_upload(create, name, strlen(name));
1706 vec_push (create, ' ');
1707 vec_upload(create, value, strlen(value));
1708 vec_push (create, 0);
1710 ftepp_preprocess_string("__builtin__", create);
1719 ftepp = ftepp_new();
1723 memset(minor, 0, sizeof(minor));
1724 memset(major, 0, sizeof(major));
1726 /* set the right macro based on the selected standard */
1727 ftepp_add_define(NULL, "GMQCC");
1728 if (opts.standard == COMPILER_FTEQCC) {
1729 ftepp_add_define(NULL, "__STD_FTEQCC__");
1738 } else if (opts.standard == COMPILER_GMQCC) {
1739 ftepp_add_define(NULL, "__STD_GMQCC__");
1740 sprintf(major, "\"%d\"", GMQCC_VERSION_MAJOR);
1741 sprintf(minor, "\"%d\"", GMQCC_VERSION_MINOR);
1742 } else if (opts.standard == COMPILER_QCCX) {
1743 ftepp_add_define(NULL, "__STD_QCCX__");
1744 sprintf(major, "\"%d\"", GMQCC_VERSION_MAJOR);
1745 sprintf(minor, "\"%d\"", GMQCC_VERSION_MINOR);
1746 } else if (opts.standard == COMPILER_QCC) {
1747 ftepp_add_define(NULL, "__STD_QCC__");
1758 ftepp_add_macro("__STD_VERSION_MINOR__", minor);
1759 ftepp_add_macro("__STD_VERSION_MAJOR__", major);
1764 void ftepp_add_define(const char *source, const char *name)
1767 lex_ctx ctx = { "__builtin__", 0 };
1769 macro = ppmacro_new(ctx, name);
1770 vec_push(ftepp->macros, macro);
1773 const char *ftepp_get()
1775 return ftepp->output_string;
1780 ftepp_flush_do(ftepp);
1787 ftepp_delete(ftepp);