/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2026 Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

// The preprocessor that Cppcheck uses is a bit special. Instead of generating

// the code for a known configuration, it generates the code for each configuration.

#include "errortypes.h"

#include "library.h"

#include "path.h"

#include "platform.h"

#include "preprocessor.h"

#include "settings.h"

#include "standards.h"

#include "suppressions.h"

#include "tokenlist.h"

#include "fixture.h"

#include "helpers.h"

#include <algorithm>

#include <cstring>

#include <iterator>

#include <list>

#include <map>

#include <set>

#include <stdexcept>

#include <string>

#include <utility>

#include <vector>

#include <simplecpp.h>

class ErrorLogger;

class TestPreprocessor : public TestFixture {

public:

TestPreprocessor() : TestFixture("TestPreprocessor") {}

private:

#define expandMacros(...) expandMacros_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

std::string expandMacros_(const char* file, int line, const char (&code)[size], ErrorLogger &errorLogger) const {

simplecpp::OutputList outputList;

std::vector<std::string> files;

simplecpp::TokenList tokens1 = simplecpp::TokenList(code, files, "file.cpp", {}, &outputList);

Preprocessor p(tokens1, settingsDefault, errorLogger, Path::identify(tokens1.getFiles()[0], false));

ASSERT_LOC(p.loadAllIncludes(files), file, line);

simplecpp::TokenList tokens2 = p.preprocess("", files, outputList);

(void)p.reportOutput(outputList, true);

return tokens2.stringify();

}

template<size_t size>

void preprocess(const char (&code)[size], std::vector<std::string> &files, const std::string& file0, TokenList& tokenlist, const simplecpp::DUI& dui)

{

if (!files.empty())

throw std::runtime_error("file list not empty");

if (tokenlist.front())

throw std::runtime_error("token list not empty");

simplecpp::OutputList outputList;

const simplecpp::TokenList tokens1(code, files, file0, dui, &outputList);

// Preprocess..

simplecpp::TokenList tokens2(files);

simplecpp::FileDataCache cache;

simplecpp::preprocess(tokens2, tokens1, files, cache, dui, &outputList);

Preprocessor preprocessor(tokens2, settingsDefault, *this, Standards::Language::C);

(void)preprocessor.reportOutput(outputList, true);

// Tokenizer..

tokenlist.createTokens(std::move(tokens2));

}

template<size_t size>

std::vector<RemarkComment> getRemarkComments(const char (&code)[size], ErrorLogger& errorLogger) const

{

std::vector<std::string> files;

simplecpp::TokenList tokens1(code, files, "test.cpp");

const Preprocessor preprocessor(tokens1, settingsDefault, errorLogger, Path::identify(tokens1.getFiles()[0], false));

return preprocessor.getRemarkComments();

}

static std::string getcodeforcfg(const Settings& settings, ErrorLogger& errorlogger, const char* code, std::size_t size, const std::string &cfg, const std::string &filename, SuppressionList *inlineSuppression = nullptr)

{

std::map<std::string, std::string> cfgcode = getcode(settings, errorlogger, code, size, std::set<std::string>{cfg}, filename, inlineSuppression);

const auto it = cfgcode.find(cfg);

if (it == cfgcode.end())

return "";

return it->second;

}

template<size_t size>

static std::string getcodeforcfg(const Settings& settings, ErrorLogger& errorlogger, const char (&code)[size], const std::string &cfg, const std::string &filename, SuppressionList *inlineSuppression = nullptr)

{

return getcodeforcfg(settings, errorlogger, code, size-1, cfg, filename, inlineSuppression);

}

template<size_t size>

static std::map<std::string, std::string> getcode(const Settings& settings, ErrorLogger& errorlogger, const char (&code)[size], const std::string &filename = "file.c")

{

return getcode(settings, errorlogger, code, size-1, {}, filename, nullptr);

}

static std::map<std::string, std::string> getcode(const Settings& settings, ErrorLogger& errorlogger, const char* code, std::size_t size, std::set<std::string> cfgs, const std::string &filename, SuppressionList *inlineSuppression)

{

simplecpp::OutputList outputList;

std::vector<std::string> files;

simplecpp::TokenList tokens({code, size}, files, Path::simplifyPath(filename), {}, &outputList);

// TODO: we should be using the actual Preprocessor implementation

Preprocessor preprocessor(tokens, settings, errorlogger, Path::identify(tokens.getFiles()[0], false));

// TODO: should be possible without a Preprocessor instance

if (preprocessor.reportOutput(outputList, true))

return {};

if (inlineSuppression)

preprocessor.inlineSuppressions(*inlineSuppression);

preprocessor.removeComments();

preprocessor.simplifyPragmaAsm();

std::map<std::string, std::string> cfgcode;

if (cfgs.empty()) {

cfgs.insert("");

std::set<std::string> configDefines = { "__cplusplus" };

preprocessor.getConfigs(configDefines, cfgs);

}

for (const std::string & config : cfgs) {

try {

const bool writeLocs = (strstr(code, "#include") != nullptr);

cfgcode[config] = preprocessor.getcode(config, files, writeLocs);

} catch (const simplecpp::Output &) {

cfgcode[config] = "";

}

}

return cfgcode;

}

const Settings settings0 = settingsBuilder().severity(Severity::information).build();

void run() override {

mNewTemplate = true;

// The bug that started the whole work with the new preprocessor

TEST_CASE(Bug2190219);

TEST_CASE(error1); // #error => don't extract any code

TEST_CASE(error2); // #error if symbol is not defined

TEST_CASE(error3);

TEST_CASE(error4); // #2919 - wrong filename is reported

TEST_CASE(error5);

TEST_CASE(error6);

TEST_CASE(error7);

TEST_CASE(error8); // #10170 -> previous #if configurations

TEST_CASE(setPlatformInfo);

// Handling include guards (don't create extra configuration for it)

TEST_CASE(includeguard1);

TEST_CASE(includeguard2);

TEST_CASE(if0);

TEST_CASE(if1);

TEST_CASE(elif);

TEST_CASE(if_cond1);

TEST_CASE(if_cond2);

TEST_CASE(if_cond3);

TEST_CASE(if_cond4);

TEST_CASE(if_cond5);

TEST_CASE(if_cond6);

TEST_CASE(if_cond8);

TEST_CASE(if_cond9);

TEST_CASE(if_cond10);

TEST_CASE(if_cond11);

TEST_CASE(if_cond12);

TEST_CASE(if_cond13);

TEST_CASE(if_cond14);

TEST_CASE(if_or_1);

TEST_CASE(if_or_2);

TEST_CASE(if_macro_eq_macro); // #3536

TEST_CASE(ticket_3675);

TEST_CASE(ticket_3699);

TEST_CASE(ticket_4922); // #4922

// Macros..

TEST_CASE(macro_simple1);

TEST_CASE(macro_simple2);

TEST_CASE(macro_simple3);

TEST_CASE(macro_simple4);

TEST_CASE(macro_simple5);

TEST_CASE(macro_simple6);

TEST_CASE(macro_simple7);

TEST_CASE(macro_simple8);

TEST_CASE(macro_simple9);

TEST_CASE(macro_simple10);

TEST_CASE(macro_simple11);

TEST_CASE(macro_simple12);

TEST_CASE(macro_simple13);

TEST_CASE(macro_simple14);

TEST_CASE(macro_simple15);

TEST_CASE(macro_simple16); // #4703: Macro parameters not trimmed

TEST_CASE(macro_simple17); // #5074: isExpandedMacro not set

TEST_CASE(macro_simple18); // (1e-7)

TEST_CASE(macroInMacro1);

TEST_CASE(macroInMacro2);

TEST_CASE(macro_linenumbers);

TEST_CASE(macro_nopar);

TEST_CASE(macro_incdec); // separate ++ and -- with space when expanding such macro: '#define M(X) A-X'

TEST_CASE(macro_switchCase);

TEST_CASE(macro_NULL); // skip #define NULL .. it is replaced in the tokenizer

TEST_CASE(string1);

TEST_CASE(string2);

TEST_CASE(string3);

TEST_CASE(preprocessor_undef);

TEST_CASE(defdef); // Defined multiple times

TEST_CASE(preprocessor_doublesharp);

TEST_CASE(preprocessor_include_in_str);

TEST_CASE(va_args_1);

//TEST_CASE(va_args_2); invalid code

TEST_CASE(va_args_3);

TEST_CASE(va_args_4);

TEST_CASE(va_args_5);

TEST_CASE(multi_character_character);

TEST_CASE(stringify);

TEST_CASE(stringify2);

TEST_CASE(stringify3);

TEST_CASE(stringify4);

TEST_CASE(stringify5);

TEST_CASE(ifdefwithfile);

TEST_CASE(pragma);

TEST_CASE(pragma_asm_1);

TEST_CASE(pragma_asm_2);

TEST_CASE(endifsemicolon);

TEST_CASE(missing_doublequote);

TEST_CASE(handle_error);

TEST_CASE(dup_defines);

TEST_CASE(define_part_of_func);

TEST_CASE(conditionalDefine);

TEST_CASE(macro_parameters);

TEST_CASE(newline_in_macro);

TEST_CASE(ifdef_ifdefined);

// define and then ifdef

TEST_CASE(define_if1);

TEST_CASE(define_if2);

TEST_CASE(define_if3);

TEST_CASE(define_if4); // #4079 - #define X +123

TEST_CASE(define_if5); // #4516 - #define B (A & 0x00f0)

TEST_CASE(define_if6); // #4863 - #define B (A?-1:1)

TEST_CASE(define_ifdef);

TEST_CASE(define_ifndef1);

TEST_CASE(define_ifndef2);

TEST_CASE(ifndef_define);

TEST_CASE(undef_ifdef);

TEST_CASE(endfile);

TEST_CASE(redundant_config);

TEST_CASE(invalid_define_1); // #2605 - hang for: '#define ='

TEST_CASE(invalid_define_2); // #4036 - hang for: '#define () {(int f(x) }'

// inline suppression, missingInclude/missingIncludeSystem

TEST_CASE(inline_suppressions);

TEST_CASE(inline_suppressions_not_next_line);

// remark comment

TEST_CASE(remarkComment1);

TEST_CASE(remarkComment2);

TEST_CASE(remarkComment3);

TEST_CASE(remarkComment4);

// Using -D to predefine symbols

TEST_CASE(predefine1);

TEST_CASE(predefine2);

TEST_CASE(predefine3);

TEST_CASE(predefine4);

TEST_CASE(predefine5); // automatically define __cplusplus

TEST_CASE(predefine6); // automatically define __STDC_VERSION__

TEST_CASE(strictAnsi);

TEST_CASE(invalidElIf); // #2942 segfault

// Preprocessor::getConfigs

TEST_CASE(getConfigs1);

TEST_CASE(getConfigs2);

TEST_CASE(getConfigs3);

TEST_CASE(getConfigs4);

TEST_CASE(getConfigs5);

TEST_CASE(getConfigs7);

TEST_CASE(getConfigs7a);

TEST_CASE(getConfigs7b);

TEST_CASE(getConfigs7c);

TEST_CASE(getConfigs7d);

TEST_CASE(getConfigs7e);

TEST_CASE(getConfigs8); // #if A==1 => cfg: A=1

TEST_CASE(getConfigs10); // #5139

TEST_CASE(getConfigs11); // #9832 - include guards

TEST_CASE(getConfigs12); // #14222

TEST_CASE(getConfigs13); // #14222

TEST_CASE(getConfigs_gte); // #1059

TEST_CASE(getConfigs_lte); // #1059

TEST_CASE(getConfigs_gt); // #1059

TEST_CASE(getConfigs_lt); // #1059

TEST_CASE(getConfigs_eq_compound); // #1059

TEST_CASE(getConfigs_gte_compound); // #1059

TEST_CASE(getConfigs_lte_compound); // #1059

TEST_CASE(getConfigs_gt_compound); // #1059

TEST_CASE(getConfigs_lt_compound); // #1059

TEST_CASE(getConfigsError);

TEST_CASE(getConfigsD1);

TEST_CASE(getConfigsU1);

TEST_CASE(getConfigsU2);

TEST_CASE(getConfigsU3);

TEST_CASE(getConfigsU4);

TEST_CASE(getConfigsU5);

TEST_CASE(getConfigsU6);

TEST_CASE(getConfigsU7);

TEST_CASE(getConfigsAndCodeIssue14317);

TEST_CASE(getConfigsMostGeneralConfigIssue14317);

TEST_CASE(getConfigsInvalid); // #14732

TEST_CASE(if_sizeof);

TEST_CASE(invalid_ifs); // #5909

TEST_CASE(garbage);

TEST_CASE(wrongPathOnErrorDirective);

TEST_CASE(testMissingInclude);

TEST_CASE(testMissingInclude2);

TEST_CASE(testMissingInclude3);

TEST_CASE(testMissingInclude4);

TEST_CASE(testMissingInclude5);

TEST_CASE(testMissingInclude6);

TEST_CASE(testMissingSystemInclude);

TEST_CASE(testMissingSystemInclude2);

TEST_CASE(testMissingSystemInclude3);

TEST_CASE(testMissingSystemInclude4);

TEST_CASE(testMissingSystemInclude5);

TEST_CASE(testMissingIncludeMixed);

TEST_CASE(testMissingIncludeCheckConfig);

TEST_CASE(testLazyInclude);

TEST_CASE(testKeepComments);

TEST_CASE(testKeepCommentsMultiline);

TEST_CASE(hasInclude);

TEST_CASE(limitsDefines);

TEST_CASE(hashCalculation);

TEST_CASE(hashCalculationIncludeOrder);

TEST_CASE(standard);

TEST_CASE(writeLocations);

TEST_CASE(pragmaAsm);

TEST_CASE(dumpPreprocessor);

}

template<size_t size>

std::string getConfigsStr(const char (&code)[size], const char *arg = nullptr, const char *library = nullptr) {

Settings settings;

if (arg && std::strncmp(arg,"-D",2)==0)

settings.userDefines = arg + 2;

if (arg && std::strncmp(arg,"-U",2)==0)

settings.userUndefs.insert(arg+2);

if (library)

ASSERT(settings.library.load("", library, false).errorcode == Library::ErrorCode::OK);

std::vector<std::string> files;

simplecpp::OutputList outputList;

simplecpp::TokenList tokens(code, files, "test.c", {}, &outputList);

Preprocessor preprocessor(tokens, settings, *this, Standards::Language::C);

std::set<std::string> configs = { "" };

std::set<std::string> configDefines = { "__cplusplus" };

const auto getDefineName = [](const std::string &defineString) {

return defineString.substr(0, defineString.find_first_of("( "));

};

std::transform(settings.library.defines().begin(),

settings.library.defines().end(),

std::inserter(configDefines, configDefines.end()),

getDefineName);

preprocessor.setLoadCallback([&](simplecpp::FileData &data, bool loaded) {

if (loaded) {

Preprocessor::removeComments(data.tokens);

preprocessor.getConfigs(data.filename, data.tokens, configDefines, configs);

}

});

preprocessor.removeComments();

preprocessor.getConfigs(configDefines, configs);

ASSERT(preprocessor.loadAllIncludes(files));

ASSERT(!preprocessor.reportOutput(outputList, true));

std::string ret;

for (const std::string & config : configs)

ret += config + '\n';

return ret;

}

template<size_t size>

std::size_t getHash(const char (&code)[size]) {

std::vector<std::string> files;

simplecpp::TokenList tokens(code,files,"test.c");

Preprocessor preprocessor(tokens, settingsDefault, *this, Standards::Language::C);

preprocessor.setLoadCallback([](simplecpp::FileData &data, bool loaded) {

if (loaded) {

Preprocessor::removeComments(data.tokens);

}

});

preprocessor.removeComments();

ASSERT(preprocessor.loadAllIncludes(files));

return preprocessor.calculateHash("");

}

void Bug2190219() {

const char filedata[] = "#ifdef __cplusplus\n"

"cpp\n"

"#else\n"

"c\n"

"#endif\n";

{

// Preprocess => actual result..

const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata, "file.cpp");

// Compare results..

ASSERT_EQUALS(1U, actual.size());

ASSERT_EQUALS("\ncpp", actual.at(""));

}

{

// Ticket #7102 - skip __cplusplus in C code

// Preprocess => actual result..

const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata, "file.c");

// Compare results..

ASSERT_EQUALS(1U, actual.size());

ASSERT_EQUALS("\n\n\nc", actual.at(""));

}

}

void error1() {

const char filedata[] = "#ifdef A\n"

";\n"

"#else\n"

"#error abcd\n"

"#endif\n";

ASSERT_EQUALS("\nA=A\n", getConfigsStr(filedata));

}

void error2() {

const char filedata1[] = "#ifndef A\n"

"#error\n"

"#endif\n";

ASSERT_EQUALS("A\n", getConfigsStr(filedata1));

const char filedata2[] = "#if !A\n"

"#error\n"

"#endif\n";

ASSERT_EQUALS("A\n", getConfigsStr(filedata2));

}

void error3() {

const auto settings = dinit(Settings, $.userDefines = "__cplusplus");

const char code[] = "#error hello world!\n";

(void)getcodeforcfg(settings, *this, code, "X", "test.c");

ASSERT_EQUALS("[test.c:1:2]: (error) #error hello world! [preprocessorErrorDirective]\n", errout_str());

}

// Ticket #2919 - wrong filename reported for #error

void error4() {

// In included file

{

ScopedFile header("ab.h", "#error hello world!\n");

const auto settings = dinit(Settings, $.userDefines = "TEST");

const char code[] = "#include \"ab.h\"\n";

(void)getcodeforcfg(settings, *this, code, "TEST", "test.c");

ASSERT_EQUALS("[ab.h:1:2]: (error) #error hello world! [preprocessorErrorDirective]\n", errout_str());

}

// After including a file

{

ScopedFile header("ab.h", "");

const auto settings = dinit(Settings, $.userDefines = "TEST");

const char code[] = "#include \"ab.h\"\n"

"#error aaa\n";

(void)getcodeforcfg(settings, *this, code, "TEST", "test.c");

ASSERT_EQUALS("[test.c:2:2]: (error) #error aaa [preprocessorErrorDirective]\n", errout_str());

}

}

void error5() {

// No message if --force is given

const auto settings = dinit(Settings,

$.userDefines = "TEST",

$.force = true);

const char code[] = "#error hello world!\n";

(void)getcodeforcfg(settings, *this, code, "X", "test.c");

ASSERT_EQUALS("", errout_str());

}

void error6() {

const char filedata1[] = "#ifdef A\n"

"#else\n"

"#error 1\n"

"#endif\n"

"#ifdef B\n"

"#else\n"

"#error 2\n"

"#endif\n";

ASSERT_EQUALS("\nA=A\nA=A;B=B\nB=B\n", getConfigsStr(filedata1));

const char filedata2[] = "#ifndef A\n"

"#error 1\n"

"#endif\n"

"#ifndef B\n"

"#error 2\n"

"#endif\n";

ASSERT_EQUALS("A;B\n", getConfigsStr(filedata2));

const char filedata3[] = "#if !A\n"

"#error 1\n"

"#endif\n"

"#if !B\n"

"#error 2\n"

"#endif\n";

ASSERT_EQUALS("A;B\n", getConfigsStr(filedata3));

}

void error7() { // #8074

const char filedata[] = "#define A\n"

"\n"

"#if defined(B)\n"

"#else\n"

"#error \"1\"\n"

"#endif\n"

"\n"

"#if defined(A)\n"

"#else\n"

"#error \"2\"\n"

"#endif\n";

ASSERT_EQUALS("\nB=B\n", getConfigsStr(filedata));

}

void error8() {

const char filedata[] = "#ifdef A\n"

"#ifdef B\n"

"#endif\n"

"#else\n"

"#endif\n"

"\n"

"#ifndef C\n"

"#error aa\n"

"#endif\n";

ASSERT_EQUALS("A=A;B=B;C\nA=A;C\nC\n", getConfigsStr(filedata));

}

void setPlatformInfo() {

// read code with simplecpp..

const char filedata[] = "#if sizeof(long) == 4\n"

"1\n"

"#else\n"

"2\n"

"#endif\n";

// preprocess code with unix32 platform..

{

std::vector<std::string> files;

simplecpp::TokenList tokens(filedata, files, "test.c");

const Settings settings = settingsBuilder().platform(Platform::Type::Unix32).build();

Preprocessor preprocessor(tokens, settings, *this, Path::identify(tokens.getFiles()[0], false));

preprocessor.setPlatformInfo();

ASSERT_EQUALS("\n1", preprocessor.getcode("", files, false));

}

// preprocess code with unix64 platform..

{

std::vector<std::string> files;

simplecpp::TokenList tokens(filedata, files, "test.c");

const Settings settings = settingsBuilder().platform(Platform::Type::Unix64).build();

Preprocessor preprocessor(tokens, settings, *this, Path::identify(tokens.getFiles()[0], false));

preprocessor.setPlatformInfo();

ASSERT_EQUALS("\n\n\n2", preprocessor.getcode("", files, false));

}

}

void includeguard1() {

ScopedFile header("abc.h",

"#ifndef abcH\n"

"#define abcH\n"

"#endif\n");

// Handling include guards..

const char filedata[] = "#include \"abc.h\"\n"

"#ifdef ABC\n"

"#endif\n";

ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));

}

void includeguard2() {

ScopedFile header("abc.h",

"foo\n"

"#ifdef ABC\n"

"\n"

"#endif\n");

// Handling include guards..

const char filedata[] = "#include \"abc.h\"\n";

ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));

}

void ifdefwithfile() {

ScopedFile header("abc.h", "class A{};/*\n\n\n\n\n\n\n*/\n");

// Handling include guards..

const char filedata[] = "#ifdef ABC\n"

"#include \"abc.h\"\n"

"#endif\n"

"int main() {}\n";

// Preprocess => actual result..

const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);

// Expected configurations: "" and "ABC"

ASSERT_EQUALS(2, actual.size());

ASSERT_EQUALS("\n\n\nint main ( ) { }", actual.at(""));

ASSERT_EQUALS("\n#line 1 \"abc.h\"\nclass A { } ;\n#line 4 \"file.c\"\n int main ( ) { }", actual.at("ABC=ABC"));

}

void if0() {

const char filedata[] = " # if /* comment */ 0 // comment\n"

"#ifdef WIN32\n"

"#endif\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void if1() {

const char filedata[] = " # if /* comment */ 1 // comment\n"

"ABC\n"

" # endif \n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void elif() {

{

const char filedata[] = "#if DEF1\n"

"ABC\n"

"#elif DEF2\n"

"DEF\n"

"#endif\n";

ASSERT_EQUALS("\nDEF1\nDEF2\n", getConfigsStr(filedata));

}

{

const char filedata[] = "#if(defined DEF1)\n"

"ABC\n"

"#elif(defined DEF2)\n"

"DEF\n"

"#else\n"

"GHI\n"

"#endif\n";

ASSERT_EQUALS("\nDEF1=DEF1\nDEF2=DEF2\n", getConfigsStr(filedata));

}

}

void if_cond1() {

const char filedata[] = "#if LIBVER>100\n"

" A\n"

"#else\n"

" B\n"

"#endif\n";

ASSERT_EQUALS("\nLIBVER=101\n", getConfigsStr(filedata));

}

void if_cond2() {

const char filedata[] = "#ifdef A\n"

"a\n"

"#endif\n"

"#if defined(A) && defined(B)\n"

"ab\n"

"#endif\n";

ASSERT_EQUALS("\nA=A\nA=A;B=B\n", getConfigsStr(filedata));

if_cond2b();

if_cond2c();

if_cond2d();

if_cond2e();

}

void if_cond2b() {

const char filedata[] = "#ifndef A\n"

"!a\n"

"#ifdef B\n"

"b\n"

"#endif\n"

"#else\n"

"a\n"

"#endif\n";

TODO_ASSERT_EQUALS("\nA;B=B\n", "\nA\nB=B\n", getConfigsStr(filedata));

}

void if_cond2c() {

const char filedata[] = "#ifndef A\n"

"!a\n"

"#ifdef B\n"

"b\n"

"#else\n"

"!b\n"

"#endif\n"

"#else\n"

"a\n"

"#endif\n";

TODO_ASSERT_EQUALS("\nA\nA;B=B\n", "\nA\nB=B\n", getConfigsStr(filedata));

}

void if_cond2d() {

const char filedata[] = "#ifndef A\n"

"!a\n"

"#ifdef B\n"

"b\n"

"#else\n"

"!b\n"

"#endif\n"

"#else\n"

"a\n"

"#ifdef B\n"

"b\n"

"#else\n"

"!b\n"

"#endif\n"

"#endif\n";

ASSERT_EQUALS("\nA\nA;B=B\nB=B\n", getConfigsStr(filedata));

}

void if_cond2e() {

const char filedata[] = "#if !defined(A)\n"

"!a\n"

"#elif !defined(B)\n"

"!b\n"

"#endif\n";

ASSERT_EQUALS("\nA\nB\n", getConfigsStr(filedata));

}

void if_cond3() {

const char filedata[] = "#ifdef A\n"

"a\n"

"#if defined(B) && defined(C)\n"

"abc\n"

"#endif\n"

"#endif\n";

ASSERT_EQUALS("\nA=A\nA=A;B=B;C=C\n", getConfigsStr(filedata));

}

void if_cond4() {

{

const char filedata[] = "#define A\n"

"#define B\n"

"#if defined A || defined B\n"

"ab\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

{

const char filedata[] = "#if A\n"

"{\n"

"#if (defined(B))\n"

"foo();\n"

"#endif\n"

"}\n"

"#endif\n";

ASSERT_EQUALS("\nA\nA;B=B\n", getConfigsStr(filedata));

}

{

const char filedata[] = "#define A\n"

"#define B\n"

"#if (defined A) || defined (B)\n"

"ab\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

{

const char filedata[] = "#if (A)\n"

"foo();\n"

"#endif\n";

ASSERT_EQUALS("\nA\n", getConfigsStr(filedata));

}

{

const char filedata[] = "#if! A\n"

"foo();\n"

"#endif\n";

ASSERT_EQUALS("\nA=0\n", getConfigsStr(filedata));

}

}

void if_cond5() {

const char filedata[] = "#if defined(A) && defined(B)\n"

"ab\n"

"#endif\n"

"cd\n"

"#if defined(B) && defined(A)\n"

"ef\n"

"#endif\n";

ASSERT_EQUALS("\nA=A;B=B\n", getConfigsStr(filedata));

}

void if_cond6() {

const char filedata[] = "\n"

"#if defined(A) && defined(B))\n"

"#endif\n";

ASSERT_EQUALS("\nA=A;B=B\n", getConfigsStr(filedata));

}

void if_cond8() {

const char filedata[] = "#if defined(A) + defined(B) + defined(C) != 1\n"

"#endif\n";

TODO_ASSERT_EQUALS("\nA=A\n", "\nA=A;B=B;C=C\n", getConfigsStr(filedata));

}

void if_cond9() {

const char filedata[] = "#if !defined _A\n"

"abc\n"

"#endif\n";

ASSERT_EQUALS("\n_A\n", getConfigsStr(filedata));

}

void if_cond10() {

const char filedata[] = "#if !defined(a) && !defined(b)\n"

"#if defined(and)\n"

"#endif\n"

"#endif\n";

// Preprocess => don't crash..

(void)getcode(settings0, *this, filedata);

}

void if_cond11() {

const char filedata[] = "#if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE\n"

"#if LIBGCC2_HAS_DF_MODE\n"

"#elif FLT_MANT_DIG < W_TYPE_SIZE\n"

"#endif\n"

"#endif\n";

(void)getcode(settings0, *this, filedata);

ASSERT_EQUALS("", errout_str());

}

void if_cond12() {

const char filedata[] = "#define A (1)\n"

"#if A == 1\n"

";\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void if_cond13() {

const char filedata[] = "#if ('A' == 0x41)\n"

"123\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void if_cond14() {

const char filedata[] = "#if !(A)\n"

"123\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(filedata));

}

void if_or_1() {

const char filedata[] = "#if defined(DEF_10) || defined(DEF_11)\n"

"a1;\n"

"#endif\n";

ASSERT_EQUALS("\nDEF_10=DEF_10;DEF_11=DEF_11\n", getConfigsStr(filedata));

}

void if_or_2() {

const char filedata[] = "#if X || Y\n"

"a1;\n"

"#endif\n";

TODO_ASSERT_EQUALS("\nX;Y\n", "\n", getConfigsStr(filedata));

}

void if_macro_eq_macro() {

const char code[] = "#define A B\n"

"#define B 1\n"

"#define C 1\n"

"#if A == C\n"

"Wilma\n"

"#else\n"

"Betty\n"

"#endif\n";

ASSERT_EQUALS("\n", getConfigsStr(code));

}

void ticket_3675() {

const char code[] = "#ifdef YYSTACKSIZE\n"

"#define YYMAXDEPTH YYSTACKSIZE\n"

"#else\n"

"#define YYSTACKSIZE YYMAXDEPTH\n"

"#endif\n"

"#if YYDEBUG\n"

"#endif\n";

(void)getcode(settings0, *this, code);

// There's nothing to assert. It just needs to not hang.

}

void ticket_3699() {

const char code[] = "#define INLINE __forceinline\n"

"#define inline __forceinline\n"

"#define __forceinline inline\n"

"#if !defined(_WIN32)\n"

"#endif\n"

"INLINE inline __forceinline\n";

const std::map<std::string, std::string> actual = getcode(settings0, *this, code);

// First, it must not hang. Second, inline must becomes inline, and __forceinline must become __forceinline.

ASSERT_EQUALS("\n\n\n\n\n$__forceinline $inline $__forceinline", actual.at(""));

}

void ticket_4922() { // #4922

const char code[] = "__asm__ \n"

"{ int extern __value) 0; (double return (\"\" } extern\n"

"__typeof __finite (__finite) __finite __inline \"__GI___finite\");\n";

(void)getcode(settings0, *this, code);

}

void macro_simple1() {

{

const char filedata[] = "#define AAA(aa) f(aa)\n"

"AAA(5);\n";

ASSERT_EQUALS("\nf ( 5 ) ;", expandMacros(filedata, *this));

}

{

const char filedata[] = "#define AAA(aa) f(aa)\n"

"AAA (5);\n";

ASSERT_EQUALS("\nf ( 5 ) ;", expandMacros(filedata, *this));

}

}

void macro_simple2() {

const char filedata[] = "#define min(x,y) x<y?x:y\n"

"min(a(),b());\n";

ASSERT_EQUALS("\na ( ) < b ( ) ? a ( ) : b ( ) ;", expandMacros(filedata, *this));

}

void macro_simple3() {

const char filedata[] = "#define A 4\n"

"A AA\n";

ASSERT_EQUALS("\n4 AA", expandMacros(filedata, *this));

}

void macro_simple4() {

const char filedata[] = "#define TEMP_1 if( temp > 0 ) return 1;\n"

"TEMP_1\n";

ASSERT_EQUALS("\nif ( temp > 0 ) return 1 ;", expandMacros(filedata, *this));

}