2 * Copyright (C) 2012, 2013, 2014, 2015
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
31 #define HT_MACROS 1024
42 /* a copy from the lexer */
56 /* yes we need an extra flag since `#define FOO x` is not the same as `#define FOO() x` */
63 typedef struct ftepp_s {
69 ppcondition *conditions;
71 ht macros; /* hashtable<string, ppmacro*> */
78 uint32_t predef_countval;
79 uint32_t predef_randval;
83 static char *ftepp_predef_date(ftepp_t *context) {
84 const struct tm *itime = NULL;
85 char *value = (char*)mem_a(82);
91 itime = util_localtime(&rtime);
92 strftime(value, 82, "\"%b %d %Y\"", itime);
98 static char *ftepp_predef_time(ftepp_t *context) {
99 const struct tm *itime = NULL;
100 char *value = (char*)mem_a(82);
106 itime = util_localtime(&rtime);
107 strftime(value, 82, "\"%X\"", itime);
113 static char *ftepp_predef_line(ftepp_t *context) {
116 util_asprintf(&value, "%d", (int)context->lex->line);
120 static char *ftepp_predef_file(ftepp_t *context) {
121 size_t length = strlen(context->lex->name) + 3; /* two quotes and a terminator */
122 char *value = (char*)mem_a(length);
124 util_snprintf(value, length, "\"%s\"", context->lex->name);
127 /* __COUNTER_LAST__ */
128 static char *ftepp_predef_counterlast(ftepp_t *context) {
130 util_asprintf(&value, "%u", context->predef_countval);
134 static char *ftepp_predef_counter(ftepp_t *context) {
137 context->predef_countval ++;
138 util_asprintf(&value, "%u", context->predef_countval);
143 static char *ftepp_predef_random(ftepp_t *context) {
146 context->predef_randval = (util_rand() % 0xFF) + 1;
147 util_asprintf(&value, "%u", context->predef_randval);
150 /* __RANDOM_LAST__ */
151 static char *ftepp_predef_randomlast(ftepp_t *context) {
154 util_asprintf(&value, "%u", context->predef_randval);
158 static char *ftepp_predef_timestamp(ftepp_t *context) {
164 if (stat(context->lex->name, &finfo))
165 return util_strdup("\"<failed to determine timestamp>\"");
167 find = util_ctime(&finfo.st_mtime);
168 value = (char*)mem_a(strlen(find) + 1);
169 memcpy(&value[1], find, (size = strlen(find)) - 1);
179 char *(*func)(ftepp_t *);
182 static const ftepp_predef_t ftepp_predefs[] = {
183 { "__LINE__", &ftepp_predef_line },
184 { "__FILE__", &ftepp_predef_file },
185 { "__COUNTER__", &ftepp_predef_counter },
186 { "__COUNTER_LAST__", &ftepp_predef_counterlast },
187 { "__RANDOM__", &ftepp_predef_random },
188 { "__RANDOM_LAST__", &ftepp_predef_randomlast },
189 { "__DATE__", &ftepp_predef_date },
190 { "__TIME__", &ftepp_predef_time },
191 { "__TIME_STAMP__", &ftepp_predef_timestamp }
194 static GMQCC_INLINE size_t ftepp_predef_index(const char *name) {
195 /* no hashtable here, we simply check for one to exist the naive way */
197 for(i = 1; i < GMQCC_ARRAY_COUNT(ftepp_predefs) + 1; i++)
198 if (!strcmp(ftepp_predefs[i-1].name, name))
203 bool ftepp_predef_exists(const char *name);
204 bool ftepp_predef_exists(const char *name) {
205 return ftepp_predef_index(name) != 0;
208 /* singleton because we're allowed */
209 static GMQCC_INLINE char *(*ftepp_predef(const char *name))(ftepp_t *context) {
210 size_t i = ftepp_predef_index(name);
211 return (i != 0) ? ftepp_predefs[i-1].func : NULL;
214 #define ftepp_tokval(f) ((f)->lex->tok.value)
215 #define ftepp_ctx(f) ((f)->lex->tok.ctx)
217 static void ftepp_errorat(ftepp_t *ftepp, lex_ctx_t ctx, const char *fmt, ...)
224 con_cvprintmsg(ctx, LVL_ERROR, "error", fmt, ap);
228 static void ftepp_error(ftepp_t *ftepp, const char *fmt, ...)
235 con_cvprintmsg(ftepp->lex->tok.ctx, LVL_ERROR, "error", fmt, ap);
239 static bool GMQCC_WARN ftepp_warn(ftepp_t *ftepp, int warntype, const char *fmt, ...)
245 r = vcompile_warning(ftepp->lex->tok.ctx, warntype, fmt, ap);
250 static pptoken *pptoken_make(ftepp_t *ftepp)
252 pptoken *token = (pptoken*)mem_a(sizeof(pptoken));
253 token->token = ftepp->token;
255 if (token->token == TOKEN_WHITE)
256 token->value = util_strdup(" ");
259 token->value = util_strdup(ftepp_tokval(ftepp));
261 memcpy(&token->constval, &ftepp->lex->tok.constval, sizeof(token->constval));
265 static GMQCC_INLINE void pptoken_delete(pptoken *self)
271 static ppmacro *ppmacro_new(lex_ctx_t ctx, const char *name)
273 ppmacro *macro = (ppmacro*)mem_a(sizeof(ppmacro));
276 memset(macro, 0, sizeof(*macro));
277 macro->name = util_strdup(name);
281 static void ppmacro_delete(ppmacro *self)
284 for (i = 0; i < vec_size(self->params); ++i)
285 mem_d(self->params[i]);
286 vec_free(self->params);
287 for (i = 0; i < vec_size(self->output); ++i)
288 pptoken_delete(self->output[i]);
289 vec_free(self->output);
294 static ftepp_t* ftepp_new(void)
298 ftepp = (ftepp_t*)mem_a(sizeof(*ftepp));
299 memset(ftepp, 0, sizeof(*ftepp));
301 ftepp->macros = util_htnew(HT_MACROS);
302 ftepp->output_on = true;
303 ftepp->predef_countval = 0;
304 ftepp->predef_randval = 0;
309 static GMQCC_INLINE void ftepp_flush_do(ftepp_t *self)
311 vec_free(self->output_string);
314 static void ftepp_delete(ftepp_t *self)
316 ftepp_flush_do(self);
318 mem_d(self->itemname);
319 if (self->includename)
320 vec_free(self->includename);
322 util_htrem(self->macros, (void (*)(void*))&ppmacro_delete);
324 vec_free(self->conditions);
326 lex_close(self->lex);
330 static void ftepp_out(ftepp_t *ftepp, const char *str, bool ignore_cond)
332 if (ignore_cond || ftepp->output_on)
337 data = vec_add(ftepp->output_string, len);
338 memcpy(data, str, len);
342 static GMQCC_INLINE void ftepp_update_output_condition(ftepp_t *ftepp)
345 ftepp->output_on = true;
346 for (i = 0; i < vec_size(ftepp->conditions); ++i)
347 ftepp->output_on = ftepp->output_on && ftepp->conditions[i].on;
350 static GMQCC_INLINE ppmacro* ftepp_macro_find(ftepp_t *ftepp, const char *name)
352 return (ppmacro*)util_htget(ftepp->macros, name);
355 static GMQCC_INLINE void ftepp_macro_delete(ftepp_t *ftepp, const char *name)
357 util_htrm(ftepp->macros, name, (void (*)(void*))&ppmacro_delete);
360 static GMQCC_INLINE int ftepp_next(ftepp_t *ftepp)
362 return (ftepp->token = lex_do(ftepp->lex));
365 /* Important: this does not skip newlines! */
366 static bool ftepp_skipspace(ftepp_t *ftepp)
368 if (ftepp->token != TOKEN_WHITE)
370 while (ftepp_next(ftepp) == TOKEN_WHITE) {}
371 if (ftepp->token >= TOKEN_EOF) {
372 ftepp_error(ftepp, "unexpected end of preprocessor directive");
378 /* this one skips EOLs as well */
379 static bool ftepp_skipallwhite(ftepp_t *ftepp)
381 if (ftepp->token != TOKEN_WHITE && ftepp->token != TOKEN_EOL)
385 } while (ftepp->token == TOKEN_WHITE || ftepp->token == TOKEN_EOL);
386 if (ftepp->token >= TOKEN_EOF) {
387 ftepp_error(ftepp, "unexpected end of preprocessor directive");
394 * The huge macro parsing code...
396 static bool ftepp_define_params(ftepp_t *ftepp, ppmacro *macro)
400 if (!ftepp_skipspace(ftepp))
402 if (ftepp->token == ')')
404 switch (ftepp->token) {
408 vec_push(macro->params, util_strdup(ftepp_tokval(ftepp)));
411 macro->variadic = true;
414 ftepp_error(ftepp, "unexpected token in parameter list");
418 if (!ftepp_skipspace(ftepp))
420 if (macro->variadic && ftepp->token != ')') {
421 ftepp_error(ftepp, "cannot have parameters after the variadic parameters");
424 } while (ftepp->token == ',');
426 if (ftepp->token != ')') {
427 ftepp_error(ftepp, "expected closing paren after macro parameter list");
431 /* skipspace happens in ftepp_define */
435 static bool ftepp_define_body(ftepp_t *ftepp, ppmacro *macro)
438 while (ftepp->token != TOKEN_EOL && ftepp->token < TOKEN_EOF) {
439 bool subscript = false;
441 if (macro->variadic && !strcmp(ftepp_tokval(ftepp), "__VA_ARGS__")) {
442 subscript = !!(ftepp_next(ftepp) == '#');
444 if (subscript && ftepp_next(ftepp) != '#') {
445 ftepp_error(ftepp, "expected `##` in __VA_ARGS__ for subscripting");
447 } else if (subscript) {
448 if (ftepp_next(ftepp) == '[') {
449 if (ftepp_next(ftepp) != TOKEN_INTCONST) {
450 ftepp_error(ftepp, "expected index for __VA_ARGS__ subscript");
454 index = (int)strtol(ftepp_tokval(ftepp), NULL, 10);
456 if (ftepp_next(ftepp) != ']') {
457 ftepp_error(ftepp, "expected `]` in __VA_ARGS__ subscript");
462 * mark it as an array to be handled later as such and not
463 * as traditional __VA_ARGS__
465 ftepp->token = TOKEN_VA_ARGS_ARRAY;
466 ptok = pptoken_make(ftepp);
467 ptok->constval.i = index;
468 vec_push(macro->output, ptok);
471 ftepp_error(ftepp, "expected `[` for subscripting of __VA_ARGS__");
475 int old = ftepp->token;
476 ftepp->token = TOKEN_VA_ARGS;
477 ptok = pptoken_make(ftepp);
478 vec_push(macro->output, ptok);
482 else if (macro->variadic && !strcmp(ftepp_tokval(ftepp), "__VA_COUNT__")) {
483 ftepp->token = TOKEN_VA_COUNT;
484 ptok = pptoken_make(ftepp);
485 vec_push(macro->output, ptok);
488 ptok = pptoken_make(ftepp);
489 vec_push(macro->output, ptok);
493 /* recursive expansion can cause EOFs here */
494 if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
495 ftepp_error(ftepp, "unexpected junk after macro or unexpected end of file");
501 static const char *ftepp_math_constants[][2] = {
502 { "M_E", "2.7182818284590452354" }, /* e */
503 { "M_LOG2E", "1.4426950408889634074" }, /* log_2 e */
504 { "M_LOG10E", "0.43429448190325182765" }, /* log_10 e */
505 { "M_LN2", "0.69314718055994530942" }, /* log_e 2 */
506 { "M_LN10", "2.30258509299404568402" }, /* log_e 10 */
507 { "M_PI", "3.14159265358979323846" }, /* pi */
508 { "M_PI_2", "1.57079632679489661923" }, /* pi/2 */
509 { "M_PI_4", "0.78539816339744830962" }, /* pi/4 */
510 { "M_1_PI", "0.31830988618379067154" }, /* 1/pi */
511 { "M_2_PI", "0.63661977236758134308" }, /* 2/pi */
512 { "M_2_SQRTPI", "1.12837916709551257390" }, /* 2/sqrt(pi) */
513 { "M_SQRT2", "1.41421356237309504880" }, /* sqrt(2) */
514 { "M_SQRT1_2", "0.70710678118654752440" }, /* 1/sqrt(2) */
515 { "M_TAU", "6.28318530717958647692" } /* pi*2 */
518 static bool ftepp_define(ftepp_t *ftepp)
520 ppmacro *macro = NULL;
521 size_t l = ftepp_ctx(ftepp).line;
523 bool mathconstant = false;
525 (void)ftepp_next(ftepp);
526 if (!ftepp_skipspace(ftepp))
529 switch (ftepp->token) {
533 if (OPTS_FLAG(FTEPP_MATHDEFS)) {
534 for (i = 0; i < GMQCC_ARRAY_COUNT(ftepp_math_constants); i++) {
535 if (!strcmp(ftepp_math_constants[i][0], ftepp_tokval(ftepp))) {
542 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
544 if (OPTS_FLAG(FTEPP_MATHDEFS)) {
545 /* user defined ones take precedence */
546 if (macro && mathconstant) {
547 ftepp_macro_delete(ftepp, ftepp_tokval(ftepp));
552 if (macro && ftepp->output_on) {
553 if (ftepp_warn(ftepp, WARN_CPP, "redefining `%s`", ftepp_tokval(ftepp)))
555 ftepp_macro_delete(ftepp, ftepp_tokval(ftepp));
557 macro = ppmacro_new(ftepp_ctx(ftepp), ftepp_tokval(ftepp));
560 ftepp_error(ftepp, "expected macro name");
564 (void)ftepp_next(ftepp);
566 if (ftepp->token == '(') {
567 macro->has_params = true;
568 if (!ftepp_define_params(ftepp, macro)) {
569 ppmacro_delete(macro);
574 if (!ftepp_skipspace(ftepp)) {
575 ppmacro_delete(macro);
579 if (!ftepp_define_body(ftepp, macro)) {
580 ppmacro_delete(macro);
584 if (ftepp->output_on)
585 util_htset(ftepp->macros, macro->name, (void*)macro);
587 ppmacro_delete(macro);
590 for (; l < ftepp_ctx(ftepp).line; ++l)
591 ftepp_out(ftepp, "\n", true);
596 * When a macro is used we have to handle parameters as well
597 * as special-concatenation via ## or stringification via #
599 * Note: parenthesis can nest, so FOO((a),b) is valid, but only
600 * this kind of parens. Curly braces or [] don't count towards the
607 static void macroparam_clean(macroparam *self)
610 for (i = 0; i < vec_size(self->tokens); ++i)
611 pptoken_delete(self->tokens[i]);
612 vec_free(self->tokens);
615 /* need to leave the last token up */
616 static bool ftepp_macro_call_params(ftepp_t *ftepp, macroparam **out_params)
618 macroparam *params = NULL;
624 if (!ftepp_skipallwhite(ftepp))
626 while (ftepp->token != ')') {
628 if (!ftepp_skipallwhite(ftepp))
630 while (parens || ftepp->token != ',') {
631 if (ftepp->token == '(')
633 else if (ftepp->token == ')') {
638 ptok = pptoken_make(ftepp);
639 vec_push(mp.tokens, ptok);
640 if (ftepp_next(ftepp) >= TOKEN_EOF) {
641 ftepp_error(ftepp, "unexpected end of file in macro call");
645 vec_push(params, mp);
647 if (ftepp->token == ')')
649 if (ftepp->token != ',') {
650 ftepp_error(ftepp, "expected closing paren or comma in macro call");
653 if (ftepp_next(ftepp) >= TOKEN_EOF) {
654 ftepp_error(ftepp, "unexpected end of file in macro call");
658 *out_params = params;
663 macroparam_clean(&mp);
664 for (i = 0; i < vec_size(params); ++i)
665 macroparam_clean(¶ms[i]);
670 static bool macro_params_find(ppmacro *macro, const char *name, size_t *idx)
673 for (i = 0; i < vec_size(macro->params); ++i) {
674 if (!strcmp(macro->params[i], name)) {
682 static void ftepp_stringify_token(ftepp_t *ftepp, pptoken *token)
687 switch (token->token) {
688 case TOKEN_STRINGCONST:
691 /* in preprocessor mode strings already are string,
692 * so we don't get actual newline bytes here.
693 * Still need to escape backslashes and quotes.
696 case '\\': ftepp_out(ftepp, "\\\\", false); break;
697 case '"': ftepp_out(ftepp, "\\\"", false); break;
700 ftepp_out(ftepp, chs, false);
707 ftepp_out(ftepp, " ", false);
710 ftepp_out(ftepp, "\\n", false);
713 ftepp_out(ftepp, token->value, false);
718 static void ftepp_stringify(ftepp_t *ftepp, macroparam *param)
721 ftepp_out(ftepp, "\"", false);
722 for (i = 0; i < vec_size(param->tokens); ++i)
723 ftepp_stringify_token(ftepp, param->tokens[i]);
724 ftepp_out(ftepp, "\"", false);
727 static void ftepp_recursion_header(ftepp_t *ftepp)
729 ftepp_out(ftepp, "\n#pragma push(line)\n", false);
732 static void ftepp_recursion_footer(ftepp_t *ftepp)
734 ftepp_out(ftepp, "\n#pragma pop(line)\n", false);
737 static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *params, bool resetline);
738 static void ftepp_param_out(ftepp_t *ftepp, macroparam *param)
742 for (i = 0; i < vec_size(param->tokens); ++i) {
743 out = param->tokens[i];
744 if (out->token == TOKEN_EOL)
745 ftepp_out(ftepp, "\n", false);
747 ppmacro *find = ftepp_macro_find(ftepp, out->value);
748 if (OPTS_FLAG(FTEPP_INDIRECT_EXPANSION) && find && !find->has_params)
749 ftepp_macro_expand(ftepp, find, NULL, false);
751 ftepp_out(ftepp, out->value, false);
756 static bool ftepp_preprocess(ftepp_t *ftepp);
757 static bool ftepp_macro_expand(ftepp_t *ftepp, ppmacro *macro, macroparam *params, bool resetline)
760 char *old_string = ftepp->output_string;
762 lex_file *old_lexer = ftepp->lex;
763 size_t vararg_start = vec_size(macro->params);
776 if (vararg_start < vec_size(params))
777 varargs = vec_size(params) - vararg_start;
782 if (!vec_size(macro->output))
785 ftepp->output_string = NULL;
786 for (o = 0; o < vec_size(macro->output); ++o) {
787 pptoken *out = macro->output[o];
788 switch (out->token) {
790 if (!macro->variadic) {
791 ftepp_error(ftepp, "internal preprocessor error: TOKEN_VA_ARGS in non-variadic macro");
792 vec_free(old_string);
799 ftepp_param_out(ftepp, ¶ms[pi + vararg_start]);
800 for (++pi; pi < varargs; ++pi) {
801 ftepp_out(ftepp, ", ", false);
802 ftepp_param_out(ftepp, ¶ms[pi + vararg_start]);
806 case TOKEN_VA_ARGS_ARRAY:
807 if ((size_t)out->constval.i >= varargs) {
808 ftepp_error(ftepp, "subscript of `[%u]` is out of bounds for `__VA_ARGS__`", out->constval.i);
809 vec_free(old_string);
813 ftepp_param_out(ftepp, ¶ms[out->constval.i + vararg_start]);
817 util_asprintf(&buffer, "%d", varargs);
818 ftepp_out(ftepp, buffer, false);
825 if (!macro_params_find(macro, out->value, &pi)) {
826 ftepp_out(ftepp, out->value, false);
829 ftepp_param_out(ftepp, ¶ms[pi]);
832 if (o + 1 < vec_size(macro->output)) {
833 nextok = macro->output[o+1]->token;
835 /* raw concatenation */
840 if ( (nextok == TOKEN_IDENT ||
841 nextok == TOKEN_KEYWORD ||
842 nextok == TOKEN_TYPENAME) &&
843 macro_params_find(macro, macro->output[o+1]->value, &pi))
847 ftepp_stringify(ftepp, ¶ms[pi]);
851 ftepp_out(ftepp, "#", false);
854 ftepp_out(ftepp, "\n", false);
858 #define buffer_stripable(X) ((X) == ' ' || (X) == '\t')
859 if (vec_size(macro->output) > o + 1 && macro->output[o+1]->token == '#' && buffer_stripable(*buffer))
862 while (buffer_stripable(*buffer)) buffer++;
865 ftepp_out(ftepp, buffer, false);
869 vec_push(ftepp->output_string, 0);
870 /* Now run the preprocessor recursively on this string buffer */
872 printf("__________\n%s\n=========\n", ftepp->output_string);
874 inlex = lex_open_string(ftepp->output_string, vec_size(ftepp->output_string)-1, ftepp->lex->name);
876 ftepp_error(ftepp, "internal error: failed to instantiate lexer");
881 inlex->line = ftepp->lex->line;
882 inlex->sline = ftepp->lex->sline;
885 old_inmacro = ftepp->in_macro;
886 ftepp->in_macro = true;
887 ftepp->output_string = NULL;
888 if (!ftepp_preprocess(ftepp)) {
889 ftepp->in_macro = old_inmacro;
890 vec_free(ftepp->lex->open_string);
891 vec_free(ftepp->output_string);
892 lex_close(ftepp->lex);
896 ftepp->in_macro = old_inmacro;
897 vec_free(ftepp->lex->open_string);
898 lex_close(ftepp->lex);
900 inner_string = ftepp->output_string;
901 ftepp->output_string = old_string;
903 has_newlines = (strchr(inner_string, '\n') != NULL);
905 if (has_newlines && !old_inmacro)
906 ftepp_recursion_header(ftepp);
908 vec_append(ftepp->output_string, vec_size(inner_string), inner_string);
909 vec_free(inner_string);
911 if (has_newlines && !old_inmacro)
912 ftepp_recursion_footer(ftepp);
914 if (resetline && !ftepp->in_macro) {
916 util_snprintf(lineno, 128, "\n#pragma line(%lu)\n", (unsigned long)(old_lexer->sline));
917 ftepp_out(ftepp, lineno, false);
920 old_string = ftepp->output_string;
922 ftepp->lex = old_lexer;
923 ftepp->output_string = old_string;
927 static bool ftepp_macro_call(ftepp_t *ftepp, ppmacro *macro)
930 macroparam *params = NULL;
934 if (!macro->has_params) {
935 if (!ftepp_macro_expand(ftepp, macro, NULL, false))
942 if (!ftepp_skipallwhite(ftepp))
945 if (ftepp->token != '(') {
946 ftepp_error(ftepp, "expected macro parameters in parenthesis");
951 paramline = ftepp->lex->sline;
952 if (!ftepp_macro_call_params(ftepp, ¶ms))
955 if ( vec_size(params) < vec_size(macro->params) ||
956 (vec_size(params) > vec_size(macro->params) && !macro->variadic) )
958 ftepp_error(ftepp, "macro %s expects%s %u paramteters, %u provided", macro->name,
959 (macro->variadic ? " at least" : ""),
960 (unsigned int)vec_size(macro->params),
961 (unsigned int)vec_size(params));
966 if (!ftepp_macro_expand(ftepp, macro, params, (paramline != ftepp->lex->sline)))
971 for (o = 0; o < vec_size(params); ++o)
972 macroparam_clean(¶ms[o]);
978 * #if - the FTEQCC way:
979 * defined(FOO) => true if FOO was #defined regardless of parameters or contents
980 * <numbers> => True if the number is not 0
981 * !<factor> => True if the factor yields false
982 * !!<factor> => ERROR on 2 or more unary nots
983 * <macro> => becomes the macro's FIRST token regardless of parameters
984 * <e> && <e> => True if both expressions are true
985 * <e> || <e> => True if either expression is true
987 * <ident> => False (remember for macros the <macro> rule applies instead)
988 * Unary + and - are weird and wrong in fteqcc so we don't allow them
989 * parenthesis in expressions are allowed
990 * parameter lists on macros are errors
991 * No mathematical calculations are executed
993 static bool ftepp_if_expr(ftepp_t *ftepp, bool *out, double *value_out);
994 static bool ftepp_if_op(ftepp_t *ftepp)
996 ftepp->lex->flags.noops = false;
998 if (!ftepp_skipspace(ftepp))
1000 ftepp->lex->flags.noops = true;
1003 static bool ftepp_if_value(ftepp_t *ftepp, bool *out, double *value_out)
1006 bool wasnot = false;
1007 bool wasneg = false;
1009 if (!ftepp_skipspace(ftepp))
1012 while (ftepp->token == '!') {
1015 if (!ftepp_skipspace(ftepp))
1019 if (ftepp->token == TOKEN_OPERATOR && !strcmp(ftepp_tokval(ftepp), "-"))
1023 if (!ftepp_skipspace(ftepp))
1027 switch (ftepp->token) {
1029 case TOKEN_TYPENAME:
1031 if (!strcmp(ftepp_tokval(ftepp), "defined")) {
1033 if (!ftepp_skipspace(ftepp))
1035 if (ftepp->token != '(') {
1036 ftepp_error(ftepp, "`defined` keyword in #if requires a macro name in parenthesis");
1040 if (!ftepp_skipspace(ftepp))
1042 if (ftepp->token != TOKEN_IDENT &&
1043 ftepp->token != TOKEN_TYPENAME &&
1044 ftepp->token != TOKEN_KEYWORD)
1046 ftepp_error(ftepp, "defined() used on an unexpected token type");
1049 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
1052 if (!ftepp_skipspace(ftepp))
1054 if (ftepp->token != ')') {
1055 ftepp_error(ftepp, "expected closing paren");
1061 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
1062 if (!macro || !vec_size(macro->output)) {
1066 /* This does not expand recursively! */
1067 switch (macro->output[0]->token) {
1068 case TOKEN_INTCONST:
1069 *value_out = macro->output[0]->constval.i;
1070 *out = !!(macro->output[0]->constval.i);
1072 case TOKEN_FLOATCONST:
1073 *value_out = macro->output[0]->constval.f;
1074 *out = !!(macro->output[0]->constval.f);
1082 case TOKEN_STRINGCONST:
1086 case TOKEN_INTCONST:
1087 *value_out = ftepp->lex->tok.constval.i;
1088 *out = !!(ftepp->lex->tok.constval.i);
1090 case TOKEN_FLOATCONST:
1091 *value_out = ftepp->lex->tok.constval.f;
1092 *out = !!(ftepp->lex->tok.constval.f);
1097 if (!ftepp_if_expr(ftepp, out, value_out))
1099 if (ftepp->token != ')') {
1100 ftepp_error(ftepp, "expected closing paren in #if expression");
1106 ftepp_error(ftepp, "junk in #if: `%s` ...", ftepp_tokval(ftepp));
1107 if (OPTS_OPTION_BOOL(OPTION_DEBUG))
1108 ftepp_error(ftepp, "internal: token %i\n", ftepp->token);
1112 *value_out = -*value_out;
1115 *value_out = (*out ? 1 : 0);
1121 static bool ftepp_if_nextvalue(ftepp_t *ftepp, bool *out, double *value_out)
1123 if (!ftepp_next(ftepp))
1125 return ftepp_if_value(ftepp, out, value_out);
1129 static bool ftepp_if_expr(ftepp_t *ftepp, bool *out, double *value_out)
1131 if (!ftepp_if_value(ftepp, out, value_out))
1134 if (!ftepp_if_op(ftepp))
1137 if (ftepp->token == ')' || ftepp->token != TOKEN_OPERATOR)
1140 /* FTEQCC is all right-associative and no precedence here */
1141 if (!strcmp(ftepp_tokval(ftepp), "&&") ||
1142 !strcmp(ftepp_tokval(ftepp), "||"))
1145 char opc = ftepp_tokval(ftepp)[0];
1149 if (!ftepp_next(ftepp))
1151 if (!ftepp_if_expr(ftepp, &next, &nextvalue))
1155 *out = *out && next;
1157 *out = *out || next;
1159 *value_out = (*out ? 1 : 0);
1162 else if (!strcmp(ftepp_tokval(ftepp), "==") ||
1163 !strcmp(ftepp_tokval(ftepp), "!=") ||
1164 !strcmp(ftepp_tokval(ftepp), ">=") ||
1165 !strcmp(ftepp_tokval(ftepp), "<=") ||
1166 !strcmp(ftepp_tokval(ftepp), ">") ||
1167 !strcmp(ftepp_tokval(ftepp), "<"))
1170 const char opc0 = ftepp_tokval(ftepp)[0];
1171 const char opc1 = ftepp_tokval(ftepp)[1];
1174 if (!ftepp_next(ftepp))
1176 if (!ftepp_if_expr(ftepp, &next, &other))
1180 *out = (*value_out == other);
1181 else if (opc0 == '!')
1182 *out = (*value_out != other);
1183 else if (opc0 == '>') {
1184 if (opc1 == '=') *out = (*value_out >= other);
1185 else *out = (*value_out > other);
1187 else if (opc0 == '<') {
1188 if (opc1 == '=') *out = (*value_out <= other);
1189 else *out = (*value_out < other);
1191 *value_out = (*out ? 1 : 0);
1196 ftepp_error(ftepp, "junk after #if");
1201 static bool ftepp_if(ftepp_t *ftepp, ppcondition *cond)
1203 bool result = false;
1206 memset(cond, 0, sizeof(*cond));
1207 (void)ftepp_next(ftepp);
1209 if (!ftepp_skipspace(ftepp))
1211 if (ftepp->token == TOKEN_EOL) {
1212 ftepp_error(ftepp, "expected expression for #if-directive");
1216 if (!ftepp_if_expr(ftepp, &result, &dummy))
1224 * ifdef is rather simple
1226 static bool ftepp_ifdef(ftepp_t *ftepp, ppcondition *cond)
1229 memset(cond, 0, sizeof(*cond));
1230 (void)ftepp_next(ftepp);
1231 if (!ftepp_skipspace(ftepp))
1234 switch (ftepp->token) {
1236 case TOKEN_TYPENAME:
1238 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
1241 ftepp_error(ftepp, "expected macro name");
1245 (void)ftepp_next(ftepp);
1246 if (!ftepp_skipspace(ftepp))
1248 /* relaxing this condition
1249 if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
1250 ftepp_error(ftepp, "stray tokens after #ifdef");
1259 * undef is also simple
1261 static bool ftepp_undef(ftepp_t *ftepp)
1263 (void)ftepp_next(ftepp);
1264 if (!ftepp_skipspace(ftepp))
1267 if (ftepp->output_on) {
1268 switch (ftepp->token) {
1270 case TOKEN_TYPENAME:
1272 ftepp_macro_delete(ftepp, ftepp_tokval(ftepp));
1275 ftepp_error(ftepp, "expected macro name");
1280 (void)ftepp_next(ftepp);
1281 if (!ftepp_skipspace(ftepp))
1283 /* relaxing this condition
1284 if (ftepp->token != TOKEN_EOL && ftepp->token != TOKEN_EOF) {
1285 ftepp_error(ftepp, "stray tokens after #ifdef");
1292 /* Special unescape-string function which skips a leading quote
1293 * and stops at a quote, not just at \0
1295 static void unescape(const char *str, char *out) {
1297 while (*str && *str != '"') {
1301 case '\\': *out++ = *str; break;
1302 case '"': *out++ = *str; break;
1303 case 'a': *out++ = '\a'; break;
1304 case 'b': *out++ = '\b'; break;
1305 case 'r': *out++ = '\r'; break;
1306 case 'n': *out++ = '\n'; break;
1307 case 't': *out++ = '\t'; break;
1308 case 'f': *out++ = '\f'; break;
1309 case 'v': *out++ = '\v'; break;
1324 static char *ftepp_include_find_path(const char *file, const char *pathfile)
1327 char *filename = NULL;
1328 const char *last_slash;
1334 last_slash = strrchr(pathfile, '/');
1337 len = last_slash - pathfile;
1338 memcpy(vec_add(filename, len), pathfile, len);
1339 vec_push(filename, '/');
1343 memcpy(vec_add(filename, len+1), file, len);
1344 vec_last(filename) = 0;
1346 fp = fs_file_open(filename, "rb");
1355 static char *ftepp_include_find(ftepp_t *ftepp, const char *file)
1357 char *filename = NULL;
1359 filename = ftepp_include_find_path(file, ftepp->includename);
1361 filename = ftepp_include_find_path(file, ftepp->itemname);
1365 static bool ftepp_directive_warning(ftepp_t *ftepp) {
1366 char *message = NULL;
1368 if (!ftepp_skipspace(ftepp))
1371 /* handle the odd non string constant case so it works like C */
1372 if (ftepp->token != TOKEN_STRINGCONST) {
1374 vec_append(message, 8, "#warning");
1376 while (ftepp->token != TOKEN_EOL) {
1377 vec_append(message, strlen(ftepp_tokval(ftepp)), ftepp_tokval(ftepp));
1380 vec_push(message, '\0');
1381 if (ftepp->output_on)
1382 store = ftepp_warn(ftepp, WARN_CPP, message);
1389 if (!ftepp->output_on)
1392 unescape (ftepp_tokval(ftepp), ftepp_tokval(ftepp));
1393 return ftepp_warn(ftepp, WARN_CPP, "#warning %s", ftepp_tokval(ftepp));
1396 static void ftepp_directive_error(ftepp_t *ftepp) {
1397 char *message = NULL;
1399 if (!ftepp_skipspace(ftepp))
1402 /* handle the odd non string constant case so it works like C */
1403 if (ftepp->token != TOKEN_STRINGCONST) {
1404 vec_append(message, 6, "#error");
1406 while (ftepp->token != TOKEN_EOL) {
1407 vec_append(message, strlen(ftepp_tokval(ftepp)), ftepp_tokval(ftepp));
1410 vec_push(message, '\0');
1411 if (ftepp->output_on)
1412 ftepp_error(ftepp, message);
1417 if (!ftepp->output_on)
1420 unescape (ftepp_tokval(ftepp), ftepp_tokval(ftepp));
1421 ftepp_error(ftepp, "#error %s", ftepp_tokval(ftepp));
1424 static void ftepp_directive_message(ftepp_t *ftepp) {
1425 char *message = NULL;
1427 if (!ftepp_skipspace(ftepp))
1430 /* handle the odd non string constant case so it works like C */
1431 if (ftepp->token != TOKEN_STRINGCONST) {
1432 vec_append(message, 8, "#message");
1434 while (ftepp->token != TOKEN_EOL) {
1435 vec_append(message, strlen(ftepp_tokval(ftepp)), ftepp_tokval(ftepp));
1438 vec_push(message, '\0');
1439 if (ftepp->output_on)
1440 con_cprintmsg(ftepp->lex->tok.ctx, LVL_MSG, "message", message);
1445 if (!ftepp->output_on)
1448 unescape (ftepp_tokval(ftepp), ftepp_tokval(ftepp));
1449 con_cprintmsg(ftepp->lex->tok.ctx, LVL_MSG, "message", ftepp_tokval(ftepp));
1454 * FIXME: do we need/want a -I option?
1455 * FIXME: what about when dealing with files in subdirectories coming from a progs.src?
1457 static bool ftepp_include(ftepp_t *ftepp)
1459 lex_file *old_lexer = ftepp->lex;
1464 char *parsename = NULL;
1465 char *old_includename;
1467 (void)ftepp_next(ftepp);
1468 if (!ftepp_skipspace(ftepp))
1471 if (ftepp->token != TOKEN_STRINGCONST) {
1472 ppmacro *macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
1474 char *backup = ftepp->output_string;
1475 ftepp->output_string = NULL;
1476 if (ftepp_macro_expand(ftepp, macro, NULL, true)) {
1477 parsename = util_strdup(ftepp->output_string);
1478 vec_free(ftepp->output_string);
1479 ftepp->output_string = backup;
1481 ftepp->output_string = backup;
1482 ftepp_error(ftepp, "expected filename to include");
1485 } else if (OPTS_FLAG(FTEPP_PREDEFS)) {
1486 /* Well it could be a predefine like __LINE__ */
1487 char *(*predef)(ftepp_t*) = ftepp_predef(ftepp_tokval(ftepp));
1489 parsename = predef(ftepp);
1491 ftepp_error(ftepp, "expected filename to include");
1497 if (!ftepp->output_on) {
1498 (void)ftepp_next(ftepp);
1503 unescape(parsename, parsename);
1505 char *tokval = ftepp_tokval(ftepp);
1506 unescape(tokval, tokval);
1507 parsename = util_strdup(tokval);
1510 ctx = ftepp_ctx(ftepp);
1511 ftepp_out(ftepp, "\n#pragma file(", false);
1512 ftepp_out(ftepp, parsename, false);
1513 ftepp_out(ftepp, ")\n#pragma line(1)\n", false);
1515 filename = ftepp_include_find(ftepp, parsename);
1517 ftepp_error(ftepp, "failed to open include file `%s`", parsename);
1522 inlex = lex_open(filename);
1524 ftepp_error(ftepp, "open failed on include file `%s`", filename);
1529 old_includename = ftepp->includename;
1530 ftepp->includename = filename;
1531 if (!ftepp_preprocess(ftepp)) {
1532 vec_free(ftepp->includename);
1533 ftepp->includename = old_includename;
1534 lex_close(ftepp->lex);
1535 ftepp->lex = old_lexer;
1538 vec_free(ftepp->includename);
1539 ftepp->includename = old_includename;
1540 lex_close(ftepp->lex);
1541 ftepp->lex = old_lexer;
1543 ftepp_out(ftepp, "\n#pragma file(", false);
1544 ftepp_out(ftepp, ctx.file, false);
1545 util_snprintf(lineno, sizeof(lineno), ")\n#pragma line(%lu)\n", (unsigned long)(ctx.line+1));
1546 ftepp_out(ftepp, lineno, false);
1549 (void)ftepp_next(ftepp);
1550 if (!ftepp_skipspace(ftepp))
1552 if (ftepp->token != TOKEN_EOL) {
1553 ftepp_error(ftepp, "stray tokens after #include");
1556 (void)ftepp_next(ftepp);
1561 /* Basic structure handlers */
1562 static bool ftepp_else_allowed(ftepp_t *ftepp)
1564 if (!vec_size(ftepp->conditions)) {
1565 ftepp_error(ftepp, "#else without #if");
1568 if (vec_last(ftepp->conditions).had_else) {
1569 ftepp_error(ftepp, "multiple #else for a single #if");
1575 static GMQCC_INLINE void ftepp_inmacro(ftepp_t *ftepp, const char *hash) {
1576 if (ftepp->in_macro)
1577 (void)!ftepp_warn(ftepp, WARN_DIRECTIVE_INMACRO, "`#%s` directive in macro", hash);
1580 static bool ftepp_hash(ftepp_t *ftepp)
1585 lex_ctx_t ctx = ftepp_ctx(ftepp);
1587 if (!ftepp_skipspace(ftepp))
1590 switch (ftepp->token) {
1593 case TOKEN_TYPENAME:
1594 if (!strcmp(ftepp_tokval(ftepp), "define")) {
1595 ftepp_inmacro(ftepp, "define");
1596 return ftepp_define(ftepp);
1598 else if (!strcmp(ftepp_tokval(ftepp), "undef")) {
1599 ftepp_inmacro(ftepp, "undef");
1600 return ftepp_undef(ftepp);
1602 else if (!strcmp(ftepp_tokval(ftepp), "ifdef")) {
1603 ftepp_inmacro(ftepp, "ifdef");
1604 if (!ftepp_ifdef(ftepp, &cond))
1606 cond.was_on = cond.on;
1607 vec_push(ftepp->conditions, cond);
1608 ftepp->output_on = ftepp->output_on && cond.on;
1611 else if (!strcmp(ftepp_tokval(ftepp), "ifndef")) {
1612 ftepp_inmacro(ftepp, "ifndef");
1613 if (!ftepp_ifdef(ftepp, &cond))
1616 cond.was_on = cond.on;
1617 vec_push(ftepp->conditions, cond);
1618 ftepp->output_on = ftepp->output_on && cond.on;
1621 else if (!strcmp(ftepp_tokval(ftepp), "elifdef")) {
1622 ftepp_inmacro(ftepp, "elifdef");
1623 if (!ftepp_else_allowed(ftepp))
1625 if (!ftepp_ifdef(ftepp, &cond))
1627 pc = &vec_last(ftepp->conditions);
1628 pc->on = !pc->was_on && cond.on;
1629 pc->was_on = pc->was_on || pc->on;
1630 ftepp_update_output_condition(ftepp);
1633 else if (!strcmp(ftepp_tokval(ftepp), "elifndef")) {
1634 ftepp_inmacro(ftepp, "elifndef");
1635 if (!ftepp_else_allowed(ftepp))
1637 if (!ftepp_ifdef(ftepp, &cond))
1640 pc = &vec_last(ftepp->conditions);
1641 pc->on = !pc->was_on && cond.on;
1642 pc->was_on = pc->was_on || pc->on;
1643 ftepp_update_output_condition(ftepp);
1646 else if (!strcmp(ftepp_tokval(ftepp), "elif")) {
1647 ftepp_inmacro(ftepp, "elif");
1648 if (!ftepp_else_allowed(ftepp))
1650 if (!ftepp_if(ftepp, &cond))
1652 pc = &vec_last(ftepp->conditions);
1653 pc->on = !pc->was_on && cond.on;
1654 pc->was_on = pc->was_on || pc->on;
1655 ftepp_update_output_condition(ftepp);
1658 else if (!strcmp(ftepp_tokval(ftepp), "if")) {
1659 ftepp_inmacro(ftepp, "if");
1660 if (!ftepp_if(ftepp, &cond))
1662 cond.was_on = cond.on;
1663 vec_push(ftepp->conditions, cond);
1664 ftepp->output_on = ftepp->output_on && cond.on;
1667 else if (!strcmp(ftepp_tokval(ftepp), "else")) {
1668 ftepp_inmacro(ftepp, "else");
1669 if (!ftepp_else_allowed(ftepp))
1671 pc = &vec_last(ftepp->conditions);
1672 pc->on = !pc->was_on;
1673 pc->had_else = true;
1675 ftepp_update_output_condition(ftepp);
1678 else if (!strcmp(ftepp_tokval(ftepp), "endif")) {
1679 ftepp_inmacro(ftepp, "endif");
1680 if (!vec_size(ftepp->conditions)) {
1681 ftepp_error(ftepp, "#endif without #if");
1684 vec_pop(ftepp->conditions);
1686 ftepp_update_output_condition(ftepp);
1689 else if (!strcmp(ftepp_tokval(ftepp), "include")) {
1690 ftepp_inmacro(ftepp, "include");
1691 return ftepp_include(ftepp);
1693 else if (!strcmp(ftepp_tokval(ftepp), "pragma")) {
1694 ftepp_out(ftepp, "#", false);
1697 else if (!strcmp(ftepp_tokval(ftepp), "warning")) {
1698 ftepp_directive_warning(ftepp);
1701 else if (!strcmp(ftepp_tokval(ftepp), "error")) {
1702 ftepp_directive_error(ftepp);
1705 else if (!strcmp(ftepp_tokval(ftepp), "message")) {
1706 ftepp_directive_message(ftepp);
1710 if (ftepp->output_on) {
1711 ftepp_error(ftepp, "unrecognized preprocessor directive: `%s`", ftepp_tokval(ftepp));
1718 /* break; never reached */
1720 ftepp_error(ftepp, "unexpected preprocessor token: `%s`", ftepp_tokval(ftepp));
1723 ftepp_errorat(ftepp, ctx, "empty preprocessor directive");
1726 ftepp_error(ftepp, "missing newline at end of file", ftepp_tokval(ftepp));
1729 /* Builtins! Don't forget the builtins! */
1730 case TOKEN_INTCONST:
1731 case TOKEN_FLOATCONST:
1732 ftepp_out(ftepp, "#", false);
1735 if (!ftepp_skipspace(ftepp))
1740 static bool ftepp_preprocess(ftepp_t *ftepp)
1743 bool newline = true;
1746 char *expand = NULL;
1748 ftepp->lex->flags.preprocessing = true;
1749 ftepp->lex->flags.mergelines = false;
1750 ftepp->lex->flags.noops = true;
1755 if (ftepp->token >= TOKEN_EOF)
1761 switch (ftepp->token) {
1764 case TOKEN_TYPENAME:
1765 /* is it a predef? */
1766 if (OPTS_FLAG(FTEPP_PREDEFS)) {
1767 char *(*predef)(ftepp_t*) = ftepp_predef(ftepp_tokval(ftepp));
1769 expand = predef(ftepp);
1770 ftepp_out (ftepp, expand, false);
1778 if (ftepp->output_on)
1779 macro = ftepp_macro_find(ftepp, ftepp_tokval(ftepp));
1784 ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1788 if (!ftepp_macro_call(ftepp, macro))
1789 ftepp->token = TOKEN_ERROR;
1793 ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1797 ftepp->lex->flags.mergelines = true;
1798 if (ftepp_next(ftepp) >= TOKEN_EOF) {
1799 ftepp_error(ftepp, "error in preprocessor directive");
1800 ftepp->token = TOKEN_ERROR;
1803 if (!ftepp_hash(ftepp))
1804 ftepp->token = TOKEN_ERROR;
1805 ftepp->lex->flags.mergelines = false;
1809 ftepp_out(ftepp, "\n", true);
1813 /* same as default but don't set newline=false */
1814 ftepp_out(ftepp, ftepp_tokval(ftepp), true);
1819 ftepp_out(ftepp, ftepp_tokval(ftepp), false);
1823 } while (!ftepp->errors && ftepp->token < TOKEN_EOF);
1825 /* force a 0 at the end but don't count it as added to the output */
1826 vec_push(ftepp->output_string, 0);
1827 vec_shrinkby(ftepp->output_string, 1);
1829 return (ftepp->token == TOKEN_EOF);
1832 /* Like in parser.c - files keep the previous state so we have one global
1833 * preprocessor. Except here we will want to warn about dangling #ifs.
1835 static bool ftepp_preprocess_done(ftepp_t *ftepp)
1838 if (vec_size(ftepp->conditions)) {
1839 if (ftepp_warn(ftepp, WARN_MULTIFILE_IF, "#if spanning multiple files, is this intended?"))
1842 lex_close(ftepp->lex);
1844 if (ftepp->itemname) {
1845 mem_d(ftepp->itemname);
1846 ftepp->itemname = NULL;
1851 bool ftepp_preprocess_file(ftepp_t *ftepp, const char *filename)
1853 ftepp->lex = lex_open(filename);
1854 ftepp->itemname = util_strdup(filename);
1856 con_out("failed to open file \"%s\"\n", filename);
1859 if (!ftepp_preprocess(ftepp))
1861 return ftepp_preprocess_done(ftepp);
1864 bool ftepp_preprocess_string(ftepp_t *ftepp, const char *name, const char *str)
1866 ftepp->lex = lex_open_string(str, strlen(str), name);
1867 ftepp->itemname = util_strdup(name);
1869 con_out("failed to create lexer for string \"%s\"\n", name);
1872 if (!ftepp_preprocess(ftepp))
1874 return ftepp_preprocess_done(ftepp);
1878 void ftepp_add_macro(ftepp_t *ftepp, const char *name, const char *value) {
1879 char *create = NULL;
1881 /* use saner path for empty macros */
1883 ftepp_add_define(ftepp, "__builtin__", name);
1887 vec_append(create, 8, "#define ");
1888 vec_append(create, strlen(name), name);
1889 vec_push (create, ' ');
1890 vec_append(create, strlen(value), value);
1891 vec_push (create, 0);
1893 ftepp_preprocess_string(ftepp, "__builtin__", create);
1897 ftepp_t *ftepp_create()
1904 ftepp = ftepp_new();
1908 memset(minor, 0, sizeof(minor));
1909 memset(major, 0, sizeof(major));
1911 /* set the right macro based on the selected standard */
1912 ftepp_add_define(ftepp, NULL, "GMQCC");
1913 if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_FTEQCC) {
1914 ftepp_add_define(ftepp, NULL, "__STD_FTEQCC__");
1923 } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) {
1924 ftepp_add_define(ftepp, NULL, "__STD_GMQCC__");
1925 util_snprintf(major, 32, "\"%d\"", GMQCC_VERSION_MAJOR);
1926 util_snprintf(minor, 32, "\"%d\"", GMQCC_VERSION_MINOR);
1927 } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCCX) {
1928 ftepp_add_define(ftepp, NULL, "__STD_QCCX__");
1929 util_snprintf(major, 32, "\"%d\"", GMQCC_VERSION_MAJOR);
1930 util_snprintf(minor, 32, "\"%d\"", GMQCC_VERSION_MINOR);
1931 } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) {
1932 ftepp_add_define(ftepp, NULL, "__STD_QCC__");
1943 ftepp_add_macro(ftepp, "__STD_VERSION_MINOR__", minor);
1944 ftepp_add_macro(ftepp, "__STD_VERSION_MAJOR__", major);
1947 * We're going to just make __NULL__ nil, which works for 60% of the
1948 * cases of __NULL_ for fteqcc.
1950 ftepp_add_macro(ftepp, "__NULL__", "nil");
1952 /* add all the math constants if they can be */
1953 if (OPTS_FLAG(FTEPP_MATHDEFS)) {
1954 for (i = 0; i < GMQCC_ARRAY_COUNT(ftepp_math_constants); i++)
1955 if (!ftepp_macro_find(ftepp, ftepp_math_constants[i][0]))
1956 ftepp_add_macro(ftepp, ftepp_math_constants[i][0], ftepp_math_constants[i][1]);
1962 void ftepp_add_define(ftepp_t *ftepp, const char *source, const char *name)
1965 lex_ctx_t ctx = { "__builtin__", 0, 0 };
1967 macro = ppmacro_new(ctx, name);
1968 /*vec_push(ftepp->macros, macro);*/
1969 util_htset(ftepp->macros, name, macro);
1972 const char *ftepp_get(ftepp_t *ftepp)
1974 return ftepp->output_string;
1977 void ftepp_flush(ftepp_t *ftepp)
1979 ftepp_flush_do(ftepp);
1982 void ftepp_finish(ftepp_t *ftepp)
1986 ftepp_delete(ftepp);